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

การฝึกอบรมกระจายกับ 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 จะกลายเป็นกลยุทธ์ที่ทราบ ซึ่งรวมถึงตัวแปร, ชั้น, รุ่น, เพิ่มประสิทธิภาพ, ตัวชี้วัด, สรุปและจุดตรวจ

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

 # Import TensorFlow
import tensorflow as tf
 

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

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

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

เพื่อรองรับกรณีการใช้งานเหล่านี้มีหกกลยุทธ์ที่มีอยู่ ในส่วนถัดไปเราจะอธิบายซึ่งของเหล่านี้ได้รับการสนับสนุนในการที่สถานการณ์ใน TF 2.2 ในขณะนี้ นี่เป็นภาพรวมอย่างรวดเร็ว:

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

MirroredStrategy

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

ที่มีประสิทธิภาพทั้งหมดลดขั้นตอนวิธีการที่ใช้ในการสื่อสารการปรับปรุงตัวแปรในอุปกรณ์ All-ลด tensors มวลรวมในทุกอุปกรณ์โดยการเพิ่มพวกเขาขึ้นและทำให้พวกเขามีอยู่ในแต่ละอุปกรณ์ มันเป็นขั้นตอนวิธีการหลอมรวมที่มีประสิทธิภาพมากและสามารถลดค่าใช้จ่ายของการประสานอย่างมีนัยสำคัญ มีหลายทั้งหมดลดขั้นตอนวิธีการและการใช้งานที่มีอยู่ขึ้นอยู่กับชนิดของการสื่อสารที่มีอยู่ระหว่างอุปกรณ์ โดยค่าเริ่มต้นจะใช้ NVIDIA 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 เป็นอุปกรณ์การสื่อสารข้าม

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

 mirrored_strategy = tf.distribute.MirroredStrategy(devices=["/gpu:0", "/gpu:1"])
 
WARNING:tensorflow:Some requested devices in `tf.distribute.Strategy` are not visible to TensorFlow: /job:localhost/replica:0/task:0/device:GPU:0,/job:localhost/replica:0/task:0/device:GPU:1
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')

หากคุณต้องการที่จะแทนที่การสื่อสารอุปกรณ์ข้ามคุณสามารถทำได้โดยใช้ 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.experimental.TPUStrategy ช่วยให้คุณสามารถเรียกใช้การฝึกอบรม TensorFlow ของคุณบน Tensor หน่วยประมวลผล (TPUs) TPUs มี ASICs เฉพาะทางของ Google ได้รับการออกแบบให้มากเร่งเครื่องการเรียนรู้ปริมาณงาน พวกเขามีอยู่ใน Google Colab ที่ TensorFlow วิจัยเมฆ และ เมฆ TPU

ในแง่ของสถาปัตยกรรมการฝึกอบรมกระจาย TPUStrategy เป็นเช่นเดียว MirroredStrategy - มันดำเนินการฝึกอบรมการกระจายซิงโคร 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.experimental.TPUStrategy(cluster_resolver)
 

TPUClusterResolver เช่นช่วยหา TPUs ใน Colab คุณไม่จำเป็นต้องระบุข้อโต้แย้งใด ๆ กับมัน

หากคุณต้องการที่จะใช้สำหรับระบบคลาวด์ TPUs:

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

MultiWorkerMirroredStrategy

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

มันใช้ CollectiveOps เป็นหลายงานทั้งหมดลดวิธีการสื่อสารมาใช้เพื่อให้ตัวแปรในการซิงค์ สหกรณ์กลุ่มเป็นสหกรณ์เดียวในกราฟ TensorFlow ซึ่งโดยอัตโนมัติสามารถเลือกทั้งหมดลดขั้นตอนวิธีการในการรันไทม์ TensorFlow ตามฮาร์ดแวร์โครงสร้างเครือข่ายและขนาดเมตริกซ์

นอกจากนี้ยังดำเนินการเพิ่มประสิทธิภาพการปฏิบัติงานเพิ่มเติม ยกตัวอย่างเช่นมันรวมถึงการเพิ่มประสิทธิภาพคงที่แปลงหลายทั้งหมดลดลงในเทนเซอร์ขนาดเล็กลงในน้อยทั้งหมดลดลงในเทนเซอร์ขนาดใหญ่ นอกจากนี้เรามีการออกแบบให้มีสถาปัตยกรรมปลั๊กอิน - เพื่อที่ว่าในอนาคตคุณจะสามารถปลั๊กอินขั้นตอนวิธีการที่จะปรับดีขึ้นสำหรับฮาร์ดแวร์ของคุณ โปรดทราบว่าการปฏิบัติการร่วมกันนอกจากนี้ยังมีการดำเนินการการดำเนินงานของกลุ่มอื่น ๆ เช่นการออกอากาศและทุกรวบรวม

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

 multiworker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
 
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:GPU:0',)
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CollectiveCommunication.AUTO

MultiWorkerMirroredStrategy ขณะนี้ช่วยให้คุณสามารถเลือกระหว่างสองการใช้งานที่แตกต่างกันของการปฏิบัติการร่วมกัน CollectiveCommunication.RING ดำเนินการสหกรณ์แหวนโดยใช้ gRPC เป็นชั้นการสื่อสาร CollectiveCommunication.NCCL ใช้ ของ Nvidia NCCL ในการดำเนินการสหกรณ์ CollectiveCommunication.AUTO คล้อยตามทางเลือกที่จะรันไทม์ เลือกที่ดีที่สุดของการดำเนินงานโดยรวมขึ้นอยู่กับจำนวนและชนิดของ GPUs และการเชื่อมต่อเครือข่ายในคลัสเตอร์ คุณสามารถระบุพวกเขาในทางต่อไปนี้:

 multiworker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(
    tf.distribute.experimental.CollectiveCommunication.NCCL)
 
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:GPU:0',)
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CollectiveCommunication.NCCL

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

CentralStorageStrategy

tf.distribute.experimental.CentralStorageStrategy ไม่ซิงโครการฝึกอบรมเป็นอย่างดี ตัวแปรที่ไม่ได้สะท้อนแทนพวกเขาจะถูกวางไว้บน CPU และการดำเนินงานจะมีการจำลองทั่ว GPUs ท้องถิ่น ถ้ามีเพียงหนึ่ง 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 Update เพื่อตัวแปรในแบบจำลองที่จะได้รับการรวบรวมก่อนที่จะถูกนำไปใช้กับตัวแปร

ParameterServerStrategy

tf.distribute.experimental.ParameterServerStrategy สนับสนุนเซิร์ฟเวอร์พารามิเตอร์การฝึกอบรมในหลายเครื่อง ในการติดตั้งนี้บางเครื่องจะกำหนดให้เป็นคนงานและบางส่วนเป็นเซิร์ฟเวอร์พารามิเตอร์ ตัวแปรของรูปแบบแต่ละครั้งจะถูกวางไว้บนเซิร์ฟเวอร์หนึ่งพารามิเตอร์ การคำนวณที่ถูกจำลองแบบทั่ว GPUs ทั้งหมดของพนักงานทุกคน

ในแง่ของรหัสที่มันมีลักษณะคล้ายกับกลยุทธ์อื่น ๆ :

 ps_strategy = tf.distribute.experimental.ParameterServerStrategy()
 

สำหรับการฝึกอบรมคนงานหลาย TF_CONFIG จำเป็นต้องระบุการกำหนดค่าของเซิร์ฟเวอร์พารามิเตอร์และคนงานในคลัสเตอร์ของคุณซึ่งคุณสามารถอ่านรายละเอียดเพิ่มเติมเกี่ยวกับใน TF_CONFIG ด้านล่าง

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

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

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

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

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

 default_strategy = tf.distribute.get_strategy()
 

กลยุทธ์นี้ทำหน้าที่สองวัตถุประสงค์หลัก

  • จะช่วยให้การเขียนการกระจายรหัสห้องสมุดตระหนักโดยไม่มีเงื่อนไข ยกตัวอย่างเช่นในการเพิ่มประสิทธิภาพที่เราสามารถทำได้ 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 default strategy
  strategy = tf.distribute.get_strategy() 

with strategy.scope():
  # do something interesting
  print(tf.Variable(1.))
 
<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>

OneDeviceStrategy

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

 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

เราสนับสนุนทุกชนิดของแบบจำลอง Keras - ลำดับการทำงานและ subclassed

นี่คือตัวอย่างของรหัสที่จะทำเช่นนี้สำหรับรูปแบบ 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')
 
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU: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',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
10/10 [==============================] - 0s 2ms/step - loss: 4.1204
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 1.8212
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
10/10 [==============================] - 0s 2ms/step - loss: 1.1310

1.1310319900512695

ที่นี่เราใช้ 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
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
10/10 [==============================] - 0s 1ms/step - loss: 0.8050
Epoch 2/2
10/10 [==============================] - 0s 1ms/step - loss: 0.3558

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

ในทั้งสองกรณี (ชุดข้อมูลหรือ numpy) ชุดของการป้อนข้อมูลที่ได้รับแต่ละคนจะแบ่งเท่า ๆ กันในหมู่ผู้ที่เลียนแบบหลาย ยกตัวอย่างเช่นถ้าใช้ MirroredStrategy มี 2 GPUs ชุดขนาด 10 แต่ละคนจะได้รับการแบ่งออกเป็น 2 GPUs กับแต่ละที่ได้รับ 5 ตัวอย่างการป้อนข้อมูลในแต่ละขั้นตอน แต่ละยุคนั้นจะฝึกได้เร็วขึ้นเมื่อคุณเพิ่ม GPUs มากขึ้น โดยปกติแล้วคุณต้องการที่จะเพิ่มขนาดของชุดของคุณเมื่อคุณเพิ่มเร่งมากขึ้นเพื่อที่จะทำให้การใช้งานที่มีประสิทธิภาพของพลังในการคำนวณพิเศษ นอกจากนี้คุณยังจะต้องมีการปรับแต่งใหม่อัตราการเรียนรู้ของคุณขึ้นอยู่กับรุ่น คุณสามารถใช้ 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 CentralStorageStrategy ParameterServerStrategy
Keras APIs ได้รับการสนับสนุน ได้รับการสนับสนุน การสนับสนุนการทดลอง การสนับสนุนการทดลอง การสนับสนุนการวางแผนการโพสต์ 2.3

ตัวอย่างและ Tutorials

นี่คือรายการของบทเรียนและตัวอย่างที่แสดงให้เห็นถึงสิ้นบูรณาการดังกล่าวข้างต้นจะจบลงด้วย Keras นี้:

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

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

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

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

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

ที่นี่เราจะแสดงข้อมูลโค้ดสั้น ๆ ที่แสดงการใช้กรณีนี้เป็นตัวอย่างการฝึกอบรมอย่างง่ายโดยใช้รูปแบบการ 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)
 

จากนั้นเราจะกำหนดขั้นตอนหนึ่งของการฝึกอบรม เราจะใช้ 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.6444106, shape=(), dtype=float32)
tf.Tensor(0.63990885, shape=(), dtype=float32)
tf.Tensor(0.63545185, shape=(), dtype=float32)
tf.Tensor(0.63103914, shape=(), dtype=float32)
tf.Tensor(0.6266703, shape=(), dtype=float32)
tf.Tensor(0.6223448, shape=(), dtype=float32)
tf.Tensor(0.61806226, shape=(), dtype=float32)
tf.Tensor(0.6138222, shape=(), dtype=float32)
tf.Tensor(0.60962415, shape=(), dtype=float32)
tf.Tensor(0.60546756, shape=(), dtype=float32)
tf.Tensor(0.6013522, shape=(), dtype=float32)
tf.Tensor(0.5972776, shape=(), dtype=float32)
tf.Tensor(0.59324306, shape=(), dtype=float32)
tf.Tensor(0.5892484, shape=(), dtype=float32)
tf.Tensor(0.58529323, shape=(), dtype=float32)
tf.Tensor(0.5813768, shape=(), dtype=float32)
tf.Tensor(0.57749903, shape=(), dtype=float32)
tf.Tensor(0.5736594, shape=(), dtype=float32)
tf.Tensor(0.5698574, shape=(), dtype=float32)
tf.Tensor(0.5660927, shape=(), dtype=float32)

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

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

 iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
 
tf.Tensor(0.562365, shape=(), dtype=float32)
tf.Tensor(0.55867356, shape=(), dtype=float32)
tf.Tensor(0.55501825, shape=(), dtype=float32)
tf.Tensor(0.5513987, shape=(), dtype=float32)
tf.Tensor(0.54781437, shape=(), dtype=float32)
tf.Tensor(0.5442649, shape=(), dtype=float32)
tf.Tensor(0.54075, shape=(), dtype=float32)
tf.Tensor(0.53726923, shape=(), dtype=float32)
tf.Tensor(0.5338222, shape=(), dtype=float32)
tf.Tensor(0.5304085, shape=(), dtype=float32)

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

สิ่งที่ได้รับการสนับสนุนในขณะนี้?

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

ตัวอย่างและ Tutorials

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

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

ใช้ tf.distribute.Strategy กับประมาณการ (การสนับสนุนอย่าง จำกัด )

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

การใช้งานของ tf.distribute.Strategy กับประมาณการแตกต่างจากกรณี Keras เล็กน้อย แทนการใช้ strategy.scope ตอนนี้เราผ่านวัตถุกลยุทธ์ที่เข้าไปใน RunConfig สำหรับประมาณการ

นี่คือข้อมูลโค้ดที่แสดงนี้ด้วยเพสตรี้ประมาณการ LinearRegressor และ MirroredStrategy :

 mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(
    train_distribute=mirrored_strategy, eval_distribute=mirrored_strategy)
regressor = tf.estimator.LinearRegressor(
    feature_columns=[tf.feature_column.numeric_column('feats')],
    optimizer='SGD',
    config=config)
 
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Initializing RunConfig with distribution strategies.
INFO:tensorflow:Not using Distribute Coordinator.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpm_7zr7im
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpm_7zr7im', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7f746e604630>, '_device_fn': None, '_protocol': None, '_eval_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7f746e604630>, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1, '_distribute_coordinator_mode': None}

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

ตอนนี้เราสามารถฝึกอบรมและประเมินผลการประมาณการนี้กับฟังก์ชั่นการป้อนข้อมูล:

 def input_fn():
  dataset = tf.data.Dataset.from_tensors(({"feats":[1.]}, [1.]))
  return dataset.repeat(1000).batch(10)
regressor.train(input_fn=input_fn, steps=10)
regressor.evaluate(input_fn=input_fn, steps=10)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.
INFO:tensorflow:Reduce to /replica:0/task:0/device:CPU:0 then broadcast to ('/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/feature_column/feature_column_v2.py:540: Layer.add_variable (from tensorflow.python.keras.engine.base_layer_v1) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.add_weight` method instead.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7f746e608a60> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7f746e608a60> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Create CheckpointSaverHook.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/util.py:96: DistributedIteratorV1.initialize (from tensorflow.python.distribute.input_lib) is deprecated and will be removed in a future version.
Instructions for updating:
Use the iterator's `initializer` property instead.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpm_7zr7im/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 10...
INFO:tensorflow:Saving checkpoints for 10 into /tmp/tmpm_7zr7im/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 10...
INFO:tensorflow:Loss for final step: 2.877698e-13.
INFO:tensorflow:Reduce to /replica:0/task:0/device:CPU:0 then broadcast to ('/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7f746e598b70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7f746e598b70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Starting evaluation at 2020-07-11T01:22:30Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpm_7zr7im/model.ckpt-10
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/10]
INFO:tensorflow:Evaluation [2/10]
INFO:tensorflow:Evaluation [3/10]
INFO:tensorflow:Evaluation [4/10]
INFO:tensorflow:Evaluation [5/10]
INFO:tensorflow:Evaluation [6/10]
INFO:tensorflow:Evaluation [7/10]
INFO:tensorflow:Evaluation [8/10]
INFO:tensorflow:Evaluation [9/10]
INFO:tensorflow:Evaluation [10/10]
INFO:tensorflow:Inference Time : 0.22353s
INFO:tensorflow:Finished evaluation at 2020-07-11-01:22:30
INFO:tensorflow:Saving dict for global step 10: average_loss = 1.4210855e-14, global_step = 10, label/mean = 1.0, loss = 1.4210855e-14, prediction/mean = 0.99999994
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 10: /tmp/tmpm_7zr7im/model.ckpt-10

{'average_loss': 1.4210855e-14,
 'label/mean': 1.0,
 'loss': 1.4210855e-14,
 'prediction/mean': 0.99999994,
 'global_step': 10}

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

คุณ input_fn เรียกว่าครั้งต่อการปฏิบัติงานจึงให้หนึ่งชุดต่อคนงาน จากนั้นหนึ่งชุดจากชุดข้อมูลที่ป้อนให้กับหนึ่งในคนงานแบบจำลองนั้นจึงต้องใช้สำหรับกระบวนการ N หา N แบบจำลองในวันที่ 1 ของผู้ปฏิบัติงาน ในคำอื่น ๆ ชุดข้อมูลที่ส่งกลับโดย input_fn ควรให้กระบวนการของขนาด PER_REPLICA_BATCH_SIZE และชุดขนาดทั่วโลกสำหรับขั้นตอนสามารถรับได้เป็น PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync

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

และในทำนองเดียวกันคุณสามารถใช้หลายคนงานและเซิร์ฟเวอร์พารามิเตอร์กลยุทธ์เช่นกัน รหัสยังคงเหมือนเดิม แต่คุณจำเป็นต้องใช้ tf.estimator.train_and_evaluate และชุด TF_CONFIG ตัวแปรสภาพแวดล้อมในการทำงานสำหรับแต่ละไบนารีในคลัสเตอร์ของคุณ

สิ่งที่ได้รับการสนับสนุนในขณะนี้?

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

การฝึกอบรม API MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
ประมาณการ API การสนับสนุนที่ จำกัด ได้รับการสนับสนุน การสนับสนุนที่ จำกัด การสนับสนุนที่ จำกัด การสนับสนุนที่ จำกัด

ตัวอย่างและ Tutorials

นี่คือตัวอย่างที่แสดงให้ยุติการใช้งานในตอนท้ายของกลยุทธ์ต่างๆที่มีการประมาณการคือ:

  1. การฝึกอบรมหลายงานกับประมาณการ ในการฝึกอบรม MNIST กับแรงงานหลายคนโดยใช้ MultiWorkerMirroredStrategy
  2. จบท้ายตัวอย่าง สำหรับการฝึกอบรมคนงานหลายใน tensorflow / ระบบนิเวศโดยใช้แม่แบบ Kubernetes ตัวอย่างนี้เริ่มต้นด้วยรูปแบบ Keras และแปลงไปสู่การประมาณการใช้ tf.keras.estimator.model_to_estimator API
  3. อย่างเป็นทางการ ResNet50 รุ่นที่สามารถผ่านการฝึกอบรมโดยใช้ MirroredStrategy หรือ MultiWorkerMirroredStrategy

หัวข้ออื่น ๆ

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

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

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

อะไรต่อไป?

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