การฝึกอบรมพนักงานหลายคนกับ Keras

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

ภาพรวม

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

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

เพื่อเรียนรู้วิธีการใช้ MultiWorkerMirroredStrategy กับ Keras และห่วงการฝึกอบรมที่กำหนดเองหมายถึง ห่วงการฝึกอบรมที่กำหนดเองกับ Keras และ MultiWorkerMirroredStrategy

โปรดทราบว่าจุดประสงค์ของบทช่วยสอนนี้คือเพื่อสาธิตตัวอย่างผู้ปฏิบัติงานหลายคนขั้นต่ำที่มีผู้ปฏิบัติงานสองคน

ติดตั้ง

เริ่มต้นด้วยการนำเข้าที่จำเป็น:

import json
import os
import sys

ก่อนนำเข้า TensorFlow ให้ทำการเปลี่ยนแปลงบางอย่างกับสภาพแวดล้อม:

  1. ปิดการใช้งาน GPU ทั้งหมด ซึ่งจะป้องกันข้อผิดพลาดที่เกิดจากพนักงานทุกคนที่พยายามใช้ GPU เดียวกัน ในการใช้งานจริง ผู้ปฏิบัติงานแต่ละคนจะอยู่บนเครื่องที่แตกต่างกัน
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
  1. รีเซ็ต TF_CONFIG ตัวแปรสภาพแวดล้อม (คุณจะเรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้ในภายหลัง):
os.environ.pop('TF_CONFIG', None)
  1. ตรวจสอบให้แน่ใจว่าไดเรกทอรีปัจจุบันอยู่ใน ธ เส้นทางนี้จะช่วยให้โน๊ตบุ๊คที่จะนำเข้าไฟล์ที่เขียนโดย %%writefile กว่า:
if '.' not in sys.path:
  sys.path.insert(0, '.')

ตอนนี้นำเข้า TensorFlow:

import tensorflow as tf

นิยามชุดข้อมูลและโมเดล

ถัดไปสร้าง mnist.py ไฟล์ที่มีรูปแบบที่เรียบง่ายและการติดตั้งชุดข้อมูล ไฟล์ Python นี้จะถูกใช้โดยกระบวนการของผู้ปฏิบัติงานในบทช่วยสอนนี้:

%%writefile mnist.py

import os
import tensorflow as tf
import numpy as np

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 [0, 255] range.
  # You need to convert them to float32 with values in the [0, 1] range.
  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

def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.layers.InputLayer(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
Writing mnist.py

การฝึกโมเดลกับคนทำงานคนเดียว

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

import mnist

batch_size = 64
single_worker_dataset = mnist.mnist_dataset(batch_size)
single_worker_model = mnist.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
11501568/11490434 [==============================] - 0s 0us/step
2021-08-20 01:21:51.478839: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:51.478914: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:51.478928: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:51.479029: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:51.479060: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:51.479067: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:51.480364: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
Epoch 1/3
 1/70 [..............................] - ETA: 26s - loss: 2.3067 - accuracy: 0.0469
2021-08-20 01:21:52.316481: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
70/70 [==============================] - 1s 12ms/step - loss: 2.2829 - accuracy: 0.1667
Epoch 2/3
70/70 [==============================] - 1s 12ms/step - loss: 2.2281 - accuracy: 0.3842
Epoch 3/3
70/70 [==============================] - 1s 12ms/step - loss: 2.1625 - accuracy: 0.5348
<keras.callbacks.History at 0x7f633d957390>

การกำหนดค่าผู้ปฏิบัติงานหลายคน

มาเข้าสู่โลกของการฝึกอบรมผู้ปฏิบัติงานหลายคนกันเถอะ

คลัสเตอร์ที่มีงานและงาน

ใน TensorFlow การฝึกอบรมที่เกี่ยวข้องกับการกระจายที่: 'cluster' กับงานหลายและแต่ละงานที่อาจจะมีหนึ่งหรือมากกว่า 'task' s

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

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

  • 'cluster' จะเหมือนกันสำหรับคนงานทุกคนและให้ข้อมูลเกี่ยวกับคลัสเตอร์การฝึกอบรมซึ่งเป็น Dict ประกอบด้วยประเภทที่แตกต่างกันของงานเช่น 'worker' หรือ 'chief'

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

ด้านล่างเป็นตัวอย่างการกำหนดค่า:

tf_config = {
    'cluster': {
        'worker': ['localhost:12345', 'localhost:23456']
    },
    'task': {'type': 'worker', 'index': 0}
}

นี่คือเดียวกัน TF_CONFIG เนื่องเป็นสตริง JSON:

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

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

ในการกำหนดค่าตัวอย่างข้างต้นคุณตั้งค่างาน 'type' เพื่อ 'worker' และงาน 'index' เพื่อ 0 ดังนั้นเครื่องนี้เป็นของผู้ปฏิบัติงานครั้งแรก มันจะได้รับการแต่งตั้งให้เป็น 'chief' คนงานและทำงานมากกว่าคนอื่น ๆ

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

ในทางปฏิบัติคุณจะสร้างคนงานหลายคนบน IP ภายนอกที่อยู่ / พอร์ตและการตั้งค่า TF_CONFIG ตัวแปรในแต่ละปฏิบัติงานตาม

ในบทช่วยสอนนี้ คุณจะใช้คนงานสองคน:

  • ครั้งแรก ( 'chief' ) คนงาน TF_CONFIG ก็แสดงให้เห็นข้างต้น
  • สำหรับผู้ปฏิบัติงานที่สองคุณจะตั้ง tf_config['task']['index']=1

ตัวแปรสภาพแวดล้อมและกระบวนการย่อยในโน้ตบุ๊ก

กระบวนการย่อยรับช่วงตัวแปรสภาพแวดล้อมจากพาเรนต์

ตัวอย่างเช่น คุณสามารถตั้งค่าตัวแปรสภาพแวดล้อมในกระบวนการ Jupyter Notebook ได้ดังนี้:

os.environ['GREETINGS'] = 'Hello TensorFlow!'

จากนั้น คุณสามารถเข้าถึงตัวแปรสภาพแวดล้อมจากกระบวนการย่อย:

echo ${GREETINGS}
Hello TensorFlow!

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

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

ใน TensorFlow การฝึกอบรมแบบกระจายมีสองรูปแบบหลัก:

  • การฝึกอบรมการซิงโครที่ขั้นตอนของการฝึกอบรมต่างๆจะซิงค์กับคนงานและแบบจำลองและ
  • การฝึกอบรมไม่ตรงกันซึ่งขั้นตอนการฝึกอบรมจะไม่ถูกซิงค์อย่างเคร่งครัด (เช่น พารามิเตอร์เซิร์ฟเวอร์ฝึกอบรม )

กวดวิชานี้จะแสดงให้เห็นถึงวิธีการดำเนินการฝึกอบรมหลายงานพร้อมกันโดยใช้ตัวอย่างของ tf.distribute.MultiWorkerMirroredStrategy

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

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:CPU:0',), communication = CommunicationImplementation.AUTO

MultiWorkerMirroredStrategy ให้การใช้งานหลายทาง CommunicationOptions พารามิเตอร์: 1) RING ดำเนินการสหกรณ์แหวนโดยใช้ gRPC เป็นชั้นการสื่อสารข้ามโฮสต์; 2) NCCL ใช้ NVIDIA Collective สื่อสารห้องสมุด ในการดำเนินการสหกรณ์; และ 3) AUTO คล้อยตามทางเลือกที่จะรันไทม์ ทางเลือกที่ดีที่สุดของการใช้งานแบบรวมขึ้นอยู่กับจำนวนและประเภทของ GPU และการเชื่อมต่อเครือข่ายในคลัสเตอร์

ฝึกโมเดล

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

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

เมื่อต้องการเรียกใช้จริงกับ MultiWorkerMirroredStrategy คุณจะต้องดำเนินการกระบวนการปฏิบัติงานและผ่านการ TF_CONFIG ให้กับพวกเขา

เช่นเดียวกับ mnist.py ไฟล์เขียนไว้ก่อนหน้านี้ที่นี่เป็น main.py ว่าแต่ละคนงานจะทำงาน:

%%writefile main.py

import os
import json

import tensorflow as tf
import mnist

per_worker_batch_size = 64
tf_config = json.loads(os.environ['TF_CONFIG'])
num_workers = len(tf_config['cluster']['worker'])

strategy = tf.distribute.MultiWorkerMirroredStrategy()

global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist.mnist_dataset(global_batch_size)

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


multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
Writing main.py

ในโค้ดข้างต้นทราบว่า global_batch_size ซึ่งได้รับการส่งผ่านไปยัง Dataset.batch ถูกตั้งค่าให้ per_worker_batch_size * num_workers เพื่อให้แน่ใจว่าพนักงานแต่ละคนจะประมวลผลสำหรับกระบวนการของ per_worker_batch_size ตัวอย่างไม่คำนึงถึงจำนวนของแรงงาน

ไดเร็กทอรีปัจจุบันมีทั้งไฟล์ Python:

ls *.py
main.py
mnist.py

ดังนั้น JSON-เป็นอันดับ TF_CONFIG และเพิ่มเข้าไปในตัวแปรสภาพแวดล้อม:

os.environ['TF_CONFIG'] = json.dumps(tf_config)

ตอนนี้คุณสามารถเปิดกระบวนการปฏิบัติงานที่จะเรียกใช้ main.py และใช้ TF_CONFIG :

# first kill any previous runs
%killbgscripts
All background processes were killed.
python main.py &> job_0.log

มีบางสิ่งที่ควรทราบเกี่ยวกับคำสั่งข้างต้น:

  1. มันใช้ %%bash ซึ่งเป็น โน๊ตบุ๊ค "วิเศษ" เรียกใช้คำสั่งทุบตีบาง
  2. มันใช้ --bg ธงเพื่อเรียกใช้ bash กระบวนการในพื้นหลังเพราะคนงานนี้จะไม่ยุติ มันรอคนงานทั้งหมดก่อนที่จะเริ่ม

ขั้นตอนการปฏิบัติงาน backgrounded จะไม่พิมพ์ส่งออกไปยังสมุดบันทึกนี้ดังนั้น &> เปลี่ยนเส้นทางการส่งออกไปยังแฟ้มเพื่อให้คุณสามารถตรวจสอบสิ่งที่เกิดขึ้นในแฟ้มบันทึกต่อมา

ดังนั้น รอสักครู่เพื่อให้กระบวนการเริ่มต้นขึ้น:

import time
time.sleep(10)

ตอนนี้ ให้ตรวจสอบสิ่งที่ส่งออกไปยังล็อกไฟล์ของพนักงาน:

cat job_0.log
2021-08-20 01:21:57.459034: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:57.459133: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459414: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459531: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:57.459575: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:57.459586: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:57.460413: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-20 01:21:57.466180: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:21:57.466667: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:12345

บรรทัดสุดท้ายของล็อกไฟล์ควรจะพูดว่า: Started server with target: grpc://localhost:12345 ตอนนี้ผู้ปฏิบัติงานคนแรกพร้อมแล้ว และกำลังรอผู้ปฏิบัติงานคนอื่นๆ ทั้งหมดให้พร้อมดำเนินการต่อไป

ดังนั้นปรับปรุง tf_config สำหรับกระบวนการปฏิบัติงานที่สองที่จะรับ:

tf_config['task']['index'] = 1
os.environ['TF_CONFIG'] = json.dumps(tf_config)

เปิดตัวคนงานที่สอง การดำเนินการนี้จะเริ่มการฝึกอบรมเนื่องจากพนักงานทุกคนทำงานอยู่ (ดังนั้นจึงไม่จำเป็นต้องดำเนินการตามขั้นตอน):

python main.py
Epoch 1/3
70/70 [==============================] - 6s 54ms/step - loss: 2.2796 - accuracy: 0.1292
Epoch 2/3
70/70 [==============================] - 4s 51ms/step - loss: 2.2285 - accuracy: 0.2898
Epoch 3/3
70/70 [==============================] - 4s 54ms/step - loss: 2.1706 - accuracy: 0.4835
2021-08-20 01:22:07.529925: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:22:07.529987: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:22:07.529996: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:22:07.530089: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:22:07.530125: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:22:07.530136: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:22:07.530785: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-20 01:22:07.536395: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:22:07.536968: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:23456
2021-08-20 01:22:08.764867: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:08.983898: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
2021-08-20 01:22:08.985655: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)

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

cat job_0.log
2021-08-20 01:21:57.459034: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:57.459133: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459414: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459531: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:57.459575: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:57.459586: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:57.460413: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-20 01:21:57.466180: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:21:57.466667: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:12345
2021-08-20 01:22:08.759563: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:08.976883: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
2021-08-20 01:22:08.978435: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
Epoch 1/3
70/70 [==============================] - 6s 54ms/step - loss: 2.2796 - accuracy: 0.1292
Epoch 2/3
70/70 [==============================] - 4s 52ms/step - loss: 2.2285 - accuracy: 0.2898
Epoch 3/3
70/70 [==============================] - 4s 54ms/step - loss: 2.1706 - accuracy: 0.4835

แปลกใจวิ่งช้ากว่านี้การทดสอบวิ่งที่จุดเริ่มต้นของการกวดวิชานี้

การเรียกใช้คนงานหลายคนในเครื่องเดียวจะเพิ่มค่าใช้จ่ายเท่านั้น

เป้าหมายที่นี่ไม่ใช่เพื่อปรับปรุงเวลาการฝึกอบรม แต่เพียงเพื่อให้ตัวอย่างการฝึกอบรมหลายคน

# Delete the `TF_CONFIG`, and kill any background tasks so they don't affect the next section.
os.environ.pop('TF_CONFIG', None)
%killbgscripts
All background processes were killed.

การฝึกอบรมพนักงานหลายคนในเชิงลึก

จนถึงตอนนี้ คุณได้เรียนรู้วิธีตั้งค่าพื้นฐานสำหรับผู้ปฏิบัติงานหลายคนแล้ว

ในช่วงที่เหลือของบทช่วยสอน คุณจะได้เรียนรู้เกี่ยวกับปัจจัยอื่นๆ ที่อาจเป็นประโยชน์หรือสำคัญสำหรับกรณีการใช้งานจริงโดยละเอียด

การแบ่งกลุ่มข้อมูล

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

ตัวอย่างในส่วนก่อนหน้านี้อาศัยอยู่กับ autosharding เริ่มต้นให้บริการโดย tf.distribute.Strategy API คุณสามารถควบคุม sharding โดยการตั้งค่า tf.data.experimental.AutoShardPolicy ของ tf.data.experimental.DistributeOptions

ต้องการเรียนรู้เพิ่มเติมเกี่ยวกับอัตโนมัติ sharding โปรดดูที่ คู่มือการป้อนข้อมูลแบบกระจาย

นี่เป็นตัวอย่างรวดเร็วของวิธีการเปิดอัตโนมัติ sharding ปิดเพื่อให้แต่ละแบบจำลองกระบวนการทุกตัวอย่าง (ไม่แนะนำ):

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

global_batch_size = 64
multi_worker_dataset = mnist.mnist_dataset(batch_size=64)
dataset_no_auto_shard = multi_worker_dataset.with_options(options)

การประเมิน

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

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

ขอแนะนำให้ใช้ชุดข้อมูลซ้ำสำหรับการประเมิน

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

ประสิทธิภาพ

ตอนนี้คุณมีรูปแบบ Keras ที่ถูกตั้งค่าทั้งหมดขึ้นอยู่กับการทำงานในหลาย ๆ คนงานกับ MultiWorkerMirroredStrategy

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

  • tf.distribute.MultiWorkerMirroredStrategy ให้หลาย การใช้งานการสื่อสารรวม :

    • RING ดำเนินการสหกรณ์แหวนโดยใช้ gRPC เป็นชั้นการสื่อสารข้ามโฮสต์
    • NCCL ใช้ NVIDIA Collective ห้องสมุดการสื่อสาร ในการดำเนินการสหกรณ์
    • AUTO คล้อยตามทางเลือกที่จะรันไทม์

    ทางเลือกที่ดีที่สุดของการใช้งานร่วมกันขึ้นอยู่กับจำนวนของ GPU ประเภทของ GPU และการเชื่อมต่อเครือข่ายในคลัสเตอร์ เมื่อต้องการแทนที่ตัวเลือกอัตโนมัติระบุ communication_options พารามิเตอร์ของ MultiWorkerMirroredStrategy คอนสตรัค 's ตัวอย่างเช่น:

    communication_options=tf.distribute.experimental.CommunicationOptions(implementation=tf.distribute.experimental.CollectiveCommunication.NCCL)
    
  • โพลล์ตัวแปรเพื่อ tf.float ถ้าเป็นไปได้:

    • รุ่น RESNET อย่างเป็นทางการรวมถึง ตัวอย่าง ของวิธีการนี้สามารถทำได้

ความทนทานต่อความผิดพลาด

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

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

เมื่อผู้ปฏิบัติงานไม่พร้อมใช้งาน ผู้ปฏิบัติงานอื่นจะล้มเหลว (อาจหลังจากหมดเวลา) ในกรณีดังกล่าว ผู้ปฏิบัติงานที่ไม่พร้อมใช้งานจำเป็นต้องเริ่มต้นใหม่ เช่นเดียวกับผู้ปฏิบัติงานอื่นที่ล้มเหลว

ModelCheckpoint โทรกลับ

ModelCheckpoint โทรกลับไม่ให้การทำงานยอมรับความผิดโปรดใช้ BackupAndRestore โทรกลับแทน

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

เลือกที่ผู้ใช้สามารถเลือกที่จะบันทึกและเรียกคืนรุ่น / น้ำหนักนอก ModelCheckpoint โทรกลับ

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

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

  • สำหรับผู้ปฏิบัติงานที่ไม่ใช่หัวหน้างาน คุณจะต้องบันทึกโมเดลไว้ในไดเร็กทอรีชั่วคราว
  • สำหรับหัวหน้า คุณจะต้องบันทึกลงในไดเร็กทอรีโมเดลที่ให้มา

ไดเร็กทอรีชั่วคราวของผู้ปฏิบัติงานต้องไม่ซ้ำกันเพื่อป้องกันข้อผิดพลาดที่เกิดจากผู้ปฏิบัติงานหลายคนพยายามเขียนไปยังตำแหน่งเดียวกัน

โมเดลที่บันทึกไว้ในไดเร็กทอรีทั้งหมดจะเหมือนกัน และโดยทั่วไปควรอ้างอิงเฉพาะโมเดลที่บันทึกไว้โดยหัวหน้าเท่านั้นเพื่อการกู้คืนหรือให้บริการ

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

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

ใช้ MultiWorkerMirroredStrategy โปรแกรมที่ถูกเรียกใช้ในทุกงานและเพื่อที่จะทราบว่าคนงานปัจจุบันเป็นหัวหน้าจะใช้ประโยชน์จากวัตถุจำแนกคลัสเตอร์ที่มีคุณลักษณะ task_type และ task_id :

  • task_type บอกคุณว่างานปัจจุบันคือ (เช่น 'worker' )
  • task_id บอกคุณระบุของคนงาน
  • ผู้ปฏิบัติงานที่มี task_id == 0 ถูกกำหนดให้เป็นหัวหน้าคนงาน

ในข้อมูลโค้ดด้านล่าง write_filepath ฟังก์ชั่นให้เส้นทางของไฟล์ที่จะเขียนซึ่งขึ้นอยู่กับผู้ปฏิบัติงานของ task_id :

  • สำหรับผู้ปฏิบัติงานหัวหน้า (กับ task_id == 0 ) ก็เขียนไปยังเส้นทางของไฟล์ต้นฉบับ
  • สำหรับคนอื่น ๆ ก็สร้างไดเรกทอรีชั่วคราว temp_dir เมื่อใช้ task_id ในเส้นทางไดเรกทอรีที่จะเขียนใน:
model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # Note: there are two possible `TF_CONFIG` configuration.
  #   1) In addition to `worker` tasks, a `chief` task type is use;
  #      in this case, this function should be modified to
  #      `return task_type == 'chief'`.
  #   2) Only `worker` task type is used; in this case, worker 0 is
  #      regarded as the chief. The implementation demonstrated here
  #      is for this case.
  # For the purpose of this Colab section, the `task_type is None` case
  # is added because it is effectively run with only a single worker.
  return (task_type == 'worker' and task_id == 0) or task_type is None

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)
2021-08-20 01:22:24.305980: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets
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() (ทราบว่า strategy = tf.distribute.MultiWorkerMirroredStrategy() ตามที่กำหนดไว้ก่อนหน้านี้ ):

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

# Now that the model is restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
Epoch 1/2
20/20 [==============================] - 1s 16ms/step - loss: 2.2960 - accuracy: 0.0000e+00
Epoch 2/2
20/20 [==============================] - 0s 15ms/step - loss: 2.2795 - accuracy: 0.0000e+00
<keras.callbacks.History at 0x7f633b103910>

การบันทึกและฟื้นฟูจุดตรวจ

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

ที่นี่คุณจะสร้าง 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)
2021-08-20 01:22:26.176660: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:26.388321: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
Epoch 1/2
20/20 [==============================] - 3s 13ms/step - loss: 2.2948 - accuracy: 0.0000e+00
Epoch 2/2
20/20 [==============================] - 0s 13ms/step - loss: 2.2785 - accuracy: 0.0000e+00
<keras.callbacks.History at 0x7f635d404450>

BackupAndRestore โทรกลับ

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

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

ที่จะใช้มันให้ตัวอย่างของ tf.keras.callbacks.experimental.BackupAndRestore ที่ Model.fit โทร

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

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

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

# Multi-worker training with MultiWorkerMirroredStrategy
# and the BackupAndRestore callback.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = mnist.build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
2021-08-20 01:22:29.530251: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}
Epoch 1/3
70/70 [==============================] - 3s 12ms/step - loss: 2.2759 - accuracy: 0.1625
Epoch 2/3
70/70 [==============================] - 1s 12ms/step - loss: 2.2146 - accuracy: 0.2761
Epoch 3/3
70/70 [==============================] - 1s 12ms/step - loss: 2.1456 - accuracy: 0.4344
<keras.callbacks.History at 0x7f635d2aac90>

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

แหล่งข้อมูลเพิ่มเติม

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