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

การฝึกอบรมผู้ทำงานหลายคนกับ Keras

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดสมุดบันทึก

ภาพรวม

บทช่วยสอนนี้แสดงให้เห็นถึงการฝึกอบรมแบบกระจายหลายคนด้วยโมเดล tf.distribute.Strategy โดยใช้ tf.distribute.Strategy API โดยเฉพาะ tf.distribute.experimental.MultiWorkerMirroredStrategy ด้วยความช่วยเหลือของกลยุทธ์นี้โมเดล Keras ที่ออกแบบมาเพื่อทำงานกับพนักงานเดี่ยวสามารถทำงานกับพนักงานหลายคนได้อย่างราบรื่นด้วยการเปลี่ยนรหัสน้อยที่สุด

การฝึกอบรมแบบกระจายใน คู่มือ TensorFlow มีให้สำหรับภาพรวมของกลยุทธ์การกระจาย TensorFlow สนับสนุนสำหรับผู้ที่สนใจในการทำความเข้าใจเชิงลึกของ tf.distribute.Strategy API

ติดตั้ง

ขั้นแรกให้ตั้งค่า TensorFlow และการนำเข้าที่จำเป็น

 import os
import tensorflow as tf
import numpy as np
 

กำลังเตรียมชุดข้อมูล

ตอนนี้มาเตรียมชุดข้อมูล MNIST ชุดข้อมูล MNIST ประกอบด้วยตัวอย่างการฝึกอบรม 60,000 ตัวอย่างและตัวอย่างการทดสอบ 10,000 หลักของลายมือที่เขียนด้วยลายมือ 0–9 ซึ่งจัดรูปแบบเป็นภาพขาวดำ 28x28 พิกเซล ในตัวอย่างนี้เราจะนำส่วนการฝึกอบรมของชุดข้อมูลไปสาธิต

 def mnist_dataset(batch_size):
  (x_train, y_train), _ = tf.keras.datasets.mnist.load_data()
  # The `x` arrays are in uint8 and have values in the range [0, 255].
  # We need to convert them to float32 with values in the range [0, 1]
  x_train = x_train / np.float32(255)
  y_train = y_train.astype(np.int64)
  train_dataset = tf.data.Dataset.from_tensor_slices(
      (x_train, y_train)).shuffle(60000).repeat().batch(batch_size)
  return train_dataset
 

สร้างโมเดล Keras

ที่นี่เราใช้ tf.keras.Sequential API เพื่อสร้างและรวบรวมโครงข่ายประสาทเทียมแบบง่าย ๆ ของ Keras เพื่อฝึกฝนกับชุดข้อมูล MNIST ของเรา

 def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.Input(shape=(28, 28)),
      tf.keras.layers.Reshape(target_shape=(28, 28, 1)),
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(10)
  ])
  model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      optimizer=tf.keras.optimizers.SGD(learning_rate=0.001),
      metrics=['accuracy'])
  return model
 

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

 per_worker_batch_size = 64
single_worker_dataset = mnist_dataset(per_worker_batch_size)
single_worker_model = build_and_compile_cnn_model()
single_worker_model.fit(single_worker_dataset, epochs=3, steps_per_epoch=70)
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
Epoch 1/3
70/70 [==============================] - 0s 2ms/step - loss: 2.2701 - accuracy: 0.2451
Epoch 2/3
70/70 [==============================] - 0s 2ms/step - loss: 2.1827 - accuracy: 0.4777
Epoch 3/3
70/70 [==============================] - 0s 2ms/step - loss: 2.0865 - accuracy: 0.5955

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

การกำหนดค่าหลายคน

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

TF_CONFIG มีสององค์ประกอบ: cluster และ task cluster ให้ข้อมูลเกี่ยวกับการฝึกอบรมกลุ่มซึ่งเป็นคำสั่งที่ประกอบด้วยงานประเภทต่าง ๆ เช่น worker ในการฝึกอบรมผู้ปฏิบัติงานหลายคนด้วย MultiWorkerMirroredStrategy มักจะมีคน worker หนึ่งที่รับผิดชอบเพิ่มเติมเล็กน้อยเช่นบันทึกจุดตรวจและเขียนไฟล์สรุปสำหรับ TensorBoard นอกเหนือจากสิ่งที่ผู้ worker ปกติทำ คนงานดังกล่าวเรียกว่า chief งานและเป็นธรรมเนียมที่ผู้ worker มี index 0 ได้รับการแต่งตั้งให้เป็นหัวหน้า worker (ในความเป็นจริงนี่คือวิธีการใช้งาน tf.distribute.Strategy ) task ในขณะที่ให้ข้อมูลของงานปัจจุบัน cluster คอมโพเนนต์แรกนั้นเหมือนกันสำหรับผู้ปฏิบัติงานทั้งหมดและ task องค์ประกอบที่สองนั้นแตกต่างกันสำหรับผู้ปฏิบัติงานแต่ละคนและระบุ type และ index ของผู้ปฏิบัติงานนั้น

ในตัวอย่างนี้เราตั้ง type งานเป็น "worker" และ index งานเป็น 0 ซึ่งหมายความว่าเครื่องจักรที่มีการตั้งค่าเช่นนี้คือพนักงานคนแรกซึ่งจะได้รับการแต่งตั้งให้เป็นหัวหน้าพนักงานและทำงานมากกว่าพนักงานคนอื่น โปรดทราบว่าเครื่องอื่น ๆ จะต้องมีการตั้งค่าตัวแปรสภาพแวดล้อม TF_CONFIG เช่นกันและควรมี cluster dict เหมือนกัน แต่ type งานหรือ index ภารกิจที่แตกต่างกันขึ้นอยู่กับบทบาทของเครื่องเหล่านั้น

สำหรับวัตถุประสงค์ภาพประกอบการกวดวิชานี้แสดงให้เห็นถึงวิธีการหนึ่งที่อาจตั้ง TF_CONFIG มี 2 คนงานใน localhost ในทางปฏิบัติผู้ใช้จะสร้างคนงานหลายคนบนที่อยู่ IP / พอร์ตภายนอกและตั้งค่า TF_CONFIG กับผู้ปฏิบัติงานแต่ละคนอย่างเหมาะสม

 os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"]
    },
    'task': {'type': 'worker', 'index': 0}
})
 

โปรดทราบว่าในขณะที่อัตราการเรียนรู้ได้รับการแก้ไขในตัวอย่างนี้โดยทั่วไปอาจจำเป็นต้องปรับอัตราการเรียนรู้ตามขนาดแบทช์ทั่วโลก

เลือกกลยุทธ์ที่เหมาะสม

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

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

 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 ใช้ collectives แบบ ring-based โดยใช้ gRPC เป็นเลเยอร์การสื่อสารข้ามโฮสต์ NCCL ใช้ NCCL ของ Nvidia เพื่อใช้งานกลุ่ม AUTO กำหนดตัวเลือกให้กับรันไทม์ ทางเลือกที่ดีที่สุดของการใช้งานแบบรวมขึ้นอยู่กับจำนวนและชนิดของ GPU และการเชื่อมต่อเครือข่ายในคลัสเตอร์

ฝึกโมเดลด้วย MultiWorkerMirroredStrategy

ด้วยการรวม tf.distribute.Strategy API เข้ากับ tf.keras การเปลี่ยนแปลงเพียงอย่างเดียวที่คุณจะทำเพื่อกระจายการฝึกอบรมไปยังผู้ปฏิบัติงานหลายคนคือการสร้างแบบจำลองการสร้างและ model.compile() โทรภายใน strategy.scope() ขอบเขตของกลยุทธ์การกระจายกำหนดวิธีและตำแหน่งที่สร้างตัวแปรและในกรณีของ MultiWorkerMirroredStrategy ตัวแปรที่สร้างขึ้นคือ MirroredVariable s และพวกมันถูกจำลองแบบในพนักงานแต่ละคน

 num_workers = 4

# Here the batch size scales up by number of workers since 
# `tf.data.Dataset.batch` expects the global batch size. Previously we used 64, 
# and now this becomes 128.
global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist_dataset(global_batch_size)

with strategy.scope():
  # Model building/compiling need to be within `strategy.scope()`.
  multi_worker_model = build_and_compile_cnn_model()

# Keras' `model.fit()` trains the model with specified number of epochs and
# number of steps per epoch. Note that the numbers here are for demonstration
# purposes only and may not sufficiently produce a model with good quality.
multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
 
Epoch 1/3
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Iterator.get_next_as_optional()` instead.
70/70 [==============================] - 0s 3ms/step - loss: 2.2682 - accuracy: 0.2265
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1714 - accuracy: 0.4954
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.0638 - accuracy: 0.6232

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

ชุดข้อมูลการแบ่งส่วนและขนาดชุดข้อมูล

ในการฝึกอบรมผู้ปฏิบัติงานหลายคนด้วย MultiWorkerMirroredStrategy การแบ่งชุดข้อมูลเป็นสิ่งจำเป็นเพื่อให้แน่ใจว่าการบรรจบกันและประสิทธิภาพ อย่างไรก็ตามโปรดทราบว่าในตัวอย่างโค้ดข้างต้นชุดข้อมูลจะถูกส่งโดยตรงไปยัง model.fit() โดยไม่จำเป็นต้องมีเศษ นี่เป็นเพราะ tf.distribute.Strategy API ดูแลชุดข้อมูลที่ทำให้แตกโดยอัตโนมัติ มันตัดชุดข้อมูลที่ระดับไฟล์ซึ่งอาจสร้างเศษที่เบ้ ในกรณีที่รุนแรงซึ่งมีไฟล์เพียงไฟล์เดียวเฉพาะเศษแรก (เช่นผู้ปฏิบัติงาน) จะได้รับข้อมูลการฝึกอบรมหรือการประเมินผลและเป็นผลให้คนงานทั้งหมดจะได้รับข้อผิดพลาด

หากคุณต้องการใช้การคัดแยกด้วยมือสำหรับการฝึกอบรมของคุณคุณสามารถปิดการใช้งานการ tf.data.experimental.DistributeOptions ผ่าน tf.data.experimental.DistributeOptions API รูปธรรม

 options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
dataset_no_auto_shard = multi_worker_dataset.with_options(options)
 

สิ่งที่ควรสังเกตอีกอย่างคือขนาดแบทช์สำหรับ datasets ในข้อมูลโค้ดด้านบนเราใช้ global_batch_size = per_worker_batch_size * num_workers ซึ่ง num_workers มีขนาดใหญ่เท่ากรณีที่ใช้สำหรับผู้ปฏิบัติงานคนเดียวเนื่องจากประสิทธิภาพต่อขนาดชุดงานทั่วโลกคือพารามิเตอร์ขนาด tf.data.Dataset.batch() ) หารด้วยจำนวนคนงานและด้วยการเปลี่ยนแปลงนี้เราจะรักษาขนาดชุดงานต่อคนงานเหมือนเดิม

การประเมินผล

ถ้าคุณผ่าน validation_data เป็น model.fit มันจะสลับกันระหว่างการฝึกอบรมและการประเมินผลสำหรับแต่ละยุค validation_data มีการแจกจ่ายข้ามชุดคนงานเดียวกันและผลการประเมินรวมและพร้อมใช้งานสำหรับพนักงานทุกคน เช่นเดียวกับการฝึกอบรมชุดการตรวจสอบความถูกต้องจะถูกแบ่งออกโดยอัตโนมัติที่ระดับไฟล์ คุณต้องตั้งค่าขนาดแบตช์ส่วนกลางในชุดข้อมูลการตรวจสอบความถูกต้องและตั้งค่า validation_steps แนะนำชุดข้อมูลซ้ำสำหรับการประเมินผล

หรือคุณสามารถสร้างงานอื่นที่อ่านจุดตรวจและเรียกใช้การประเมินเป็นระยะ นี่คือสิ่งที่เครื่องมือประมาณการใช้ แต่นี่ไม่ใช่วิธีที่แนะนำในการประเมินผลและรายละเอียดจะถูกละเว้น

คาดการณ์

model.predict ปัจจุบันไม่สามารถใช้งานได้กับ MultiWorkerMirroredStrategy.

ประสิทธิภาพ

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

  • MultiWorkerMirroredStrategy จัดเตรียม การประยุกต์ใช้การสื่อสารแบบ หลายส่วน RING ใช้ collectives แบบ ring-based โดยใช้ gRPC เป็นเลเยอร์การสื่อสารข้ามโฮสต์ NCCL ใช้ NCCL ของ Nvidia เพื่อใช้งานกลุ่ม AUTO กำหนดตัวเลือกให้กับรันไทม์ ทางเลือกที่ดีที่สุดของการใช้งานแบบรวมขึ้นอยู่กับจำนวนและชนิดของ GPU และการเชื่อมต่อเครือข่ายในคลัสเตอร์ ในการลบล้างตัวเลือกอัตโนมัติให้ระบุค่าที่ถูกต้องกับพารามิเตอร์ communication ของ MultiWorkerMirroredStrategy ของ MultiWorkerMirroredStrategy เช่น communication=tf.distribute.experimental.CollectiveCommunication.NCCL
  • ส่งตัวแปรไปที่ tf.float ถ้าเป็นไปได้ โมเดล ResNet อย่างเป็นทางการรวมถึง ตัวอย่าง ของวิธีการนี้สามารถทำได้

ข้อผิดพลาดความอดทน

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

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

ModelCheckpoint การโทรกลับ

ModelCheckpoint callback ไม่มีฟังก์ชันการรับความผิดพลาดอีกต่อไปโปรดใช้ BackupAndRestore callback แทน

ModelCheckpoint callback ยังคงสามารถใช้เพื่อบันทึกจุดตรวจสอบได้ แต่ด้วยสิ่งนี้หากการฝึกอบรมถูกขัดจังหวะหรือเสร็จสิ้นเรียบร้อยแล้วเพื่อดำเนินการฝึกอบรมจากจุดตรวจสอบต่อไปผู้ใช้จะต้องรับผิดชอบในการโหลดแบบจำลองด้วยตนเอง ผู้ใช้สามารถเลือกที่จะบันทึกและเรียกคืนโมเดล / น้ำหนักภายนอก ModelCheckpoint callback

การบันทึกและการโหลดโมเดล

ในการบันทึกโมเดลของคุณโดยใช้ model.save หรือ tf.saved_model.save ปลายทางสำหรับการบันทึกจะต้องแตกต่างกันสำหรับผู้ปฏิบัติงานแต่ละคน สำหรับผู้ทำงานที่ไม่ใช่หัวหน้าคุณจะต้องบันทึกโมเดลไปยังไดเร็กทอรีชั่วคราวและบนหัวหน้าคุณจะต้องบันทึกลงในไดเร็กทอรีโมเดลที่จัดเตรียมไว้ ไดเรกทอรีชั่วคราวในผู้ปฏิบัติงานจะต้องไม่ซ้ำกันเพื่อป้องกันข้อผิดพลาดที่เกิดจากคนงานหลายคนพยายามที่จะเขียนไปยังตำแหน่งเดียวกัน โมเดลที่บันทึกในไดเร็กทอรีทั้งหมดเหมือนกันและโดยทั่วไปควรอ้างอิงโมเดลที่บันทึกไว้โดยหัวหน้าเท่านั้นสำหรับการกู้คืนหรือการให้บริการ เราขอแนะนำให้คุณมีตรรกะการล้างข้อมูลที่จะลบไดเรกทอรีชั่วคราวที่สร้างโดยคนงานเมื่อการฝึกอบรมของคุณเสร็จสิ้น

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

ด้วย MultiWorkerMirroredStrategy โปรแกรมจะทำงานกับผู้ปฏิบัติงานทุกคนและเพื่อที่จะทราบว่าผู้ปฏิบัติงานปัจจุบันเป็นหัวหน้าหรือไม่เราใช้ประโยชน์จากวัตถุตัวแก้ไขคลัสเตอร์ที่มีคุณลักษณะ task_type และ task_id task_type บอกคุณว่างานปัจจุบันคืออะไร (เช่น 'ผู้ปฏิบัติงาน') และ task_id จะบอกคุณถึงตัวระบุของผู้ปฏิบัติงาน ผู้ปฏิบัติงานที่มี id 0 ถูกกำหนดให้เป็นหัวหน้าคนงาน

ในข้อมูลโค้ดด้านล่าง write_filepath จัดเตรียมพา ธ ไฟล์ที่จะเขียนซึ่งขึ้นอยู่กับ id ผู้ปฏิบัติงาน ในกรณีของหัวหน้า (ผู้ปฏิบัติงานที่มี id 0) มันเขียนไปยังเส้นทางไฟล์ต้นฉบับ สำหรับคนอื่น ๆ มันสร้างไดเรกทอรีชั่วคราว (ที่มี id ในเส้นทางไดเรกทอรี) เพื่อเขียนใน:

 model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # If `task_type` is None, this may be operating as single worker, which works 
  # effectively as chief.
  return task_type is None or task_type == 'chief' or (
            task_type == 'worker' and task_id == 0)

def _get_temp_dir(dirpath, task_id):
  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir

def write_filepath(filepath, task_type, task_id):
  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

task_type, task_id = (strategy.cluster_resolver.task_type,
                      strategy.cluster_resolver.task_id)
write_model_path = write_filepath(model_path, task_type, task_id)
 

ด้วยสิ่งนี้คุณพร้อมที่จะบันทึก:

 multi_worker_model.save(write_model_path)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets

ดังที่เราได้อธิบายไว้ข้างต้นควรโหลดจากตัวแบบพา ธ ที่บันทึกไว้ในภายหลังเท่านั้นดังนั้นขอให้ลบแบบชั่วคราวที่ไม่ใช่หัวหน้างานที่บันทึกไว้:

 if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(os.path.dirname(write_model_path))
 

ตอนนี้เมื่อถึงเวลาโหลดลองใช้ tf.keras.models.load_model API ที่แสนสะดวกและทำงานต่อไป ที่นี่เราสมมติว่าใช้ผู้ปฏิบัติงานคนเดียวเท่านั้นในการโหลดและฝึกอบรมอย่างต่อเนื่องซึ่งในกรณีนี้คุณจะไม่เรียก tf.keras.models.load_model ภายใน strategy.scope() อื่น

 loaded_model = tf.keras.models.load_model(model_path)

# Now that we have the model restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9825 - accuracy: 0.1102
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9367 - accuracy: 0.1117

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

ด่านการออมและการคืนค่า

ในทางกลับกันจุดตรวจช่วยให้คุณสามารถบันทึกน้ำหนักของแบบจำลองและเรียกคืนได้โดยไม่ต้องบันทึกแบบจำลองทั้งหมด ที่นี่คุณจะสร้างหนึ่ง tf.train.Checkpoint ที่ติดตามรุ่นซึ่งจัดการโดย tf.train.CheckpointManager เพื่อให้เฉพาะจุดตรวจล่าสุดเท่านั้น

 checkpoint_dir = '/tmp/ckpt'

checkpoint = tf.train.Checkpoint(model=multi_worker_model)
write_checkpoint_dir = write_filepath(checkpoint_dir, task_type, task_id)
checkpoint_manager = tf.train.CheckpointManager(
  checkpoint, directory=write_checkpoint_dir, max_to_keep=1)
 

เมื่อตั้งค่า CheckpointManager แล้วตอนนี้คุณพร้อมที่จะบันทึกและลบจุดตรวจที่ไม่ใช่หัวหน้างานที่บันทึกไว้

 checkpoint_manager.save()
if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(write_checkpoint_dir)
 

ตอนนี้เมื่อคุณต้องการกู้คืนคุณสามารถค้นหาจุดตรวจสอบล่าสุดที่บันทึกไว้โดยใช้ฟังก์ชัน tf.train.latest_checkpoint สะดวก หลังจากเรียกคืนจุดตรวจคุณสามารถทำการฝึกต่อได้

 latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
checkpoint.restore(latest_checkpoint)
multi_worker_model.fit(multi_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9841 - accuracy: 0.6561
Epoch 2/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9445 - accuracy: 0.6805

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

BackupAndRestore โทรกลับ

BackupAndRestore callback จัดเตรียมฟังก์ชันการยอมรับความผิดพลาดโดยการสำรองข้อมูลรุ่นและหมายเลข epoch ปัจจุบันในไฟล์จุดตรวจสอบชั่วคราวภายใต้อาร์กิวเมนต์ backup_dir เพื่อ BackupAndRestore นี่จะทำในตอนท้ายของแต่ละยุค

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

หากต้องการใช้ให้ระบุอินสแตนซ์ของ tf.keras.callbacks.experimental.BackupAndRestore ที่การ tf.keras.Model.fit()

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

BackupAndRestore callback ใช้ CheckpointManager เพื่อบันทึกและเรียกคืนสถานะการฝึกอบรมซึ่งสร้างไฟล์ชื่อจุดตรวจสอบที่ติดตามจุดตรวจสอบที่มีอยู่พร้อมกับรายการล่าสุด ด้วยเหตุผลนี้ backup_dir ไม่ควรถูกนำมาใช้ซ้ำเพื่อจัดเก็บจุดตรวจสอบอื่น ๆ เพื่อหลีกเลี่ยงการชนกันของชื่อ

ขณะนี้การเรียกกลับ BackupAndRestore สนับสนุนผู้ปฏิบัติงานเดี่ยวโดยไม่มีกลยุทธ์ MirroredStrategy และผู้ทำงานหลายคนที่มี MultiWorkerMirroredStrategy ด้านล่างนี้เป็นสองตัวอย่างสำหรับการฝึกอบรมผู้ทำงานหลายคนและการฝึกอบรมผู้ปฏิบัติงานคนเดียว

 # Multi-worker training with MultiWorkerMirroredStrategy.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
 
Epoch 1/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2837 - accuracy: 0.1836
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2131 - accuracy: 0.4091
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1310 - accuracy: 0.5485

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

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

ดูสิ่งนี้ด้วย

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