1. ภาพรวม
ในชั้นเรียนนี้ คุณจะใช้ Vertex AI เพื่อเรียกใช้งานการฝึกแบบกระจายในการฝึก Vertex AI โดยใช้ TensorFlow
วิดีโอนี้เป็นส่วนหนึ่งของซีรีส์วิดีโอจากต้นแบบสู่เวอร์ชันที่ใช้งานจริง โปรดทำห้องทดลองก่อนหน้าให้เสร็จก่อนลองใช้ห้องทดลองนี้ คุณดูข้อมูลเพิ่มเติมได้จากชุดวิดีโอประกอบ
.
สิ่งที่คุณเรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- เรียกใช้การฝึกแบบกระจายในเครื่องเดียวที่มี GPU หลายตัว
- เรียกใช้การฝึกแบบกระจายในหลายเครื่อง
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $2
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย
Vertex AI มีผลิตภัณฑ์ต่างๆ มากมายเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การฝึกอบรมและ Workbench
3. ภาพรวมการฝึกแบบกระจาย
หากคุณมี GPU เพียงตัวเดียว TensorFlow จะใช้ตัวเร่งนี้เพื่อเร่งการฝึกโมเดลโดยที่คุณไม่ต้องดำเนินการใดๆ เพิ่มเติม อย่างไรก็ตาม หากต้องการเพิ่มประสิทธิภาพโดยใช้ GPU หลายตัว คุณจะต้องใช้ tf.distribute ซึ่งเป็นโมดูลของ TensorFlow สำหรับเรียกใช้การคํานวณในอุปกรณ์หลายเครื่อง
ส่วนแรกของห้องทดลองนี้ใช้ tf.distribute.MirroredStrategy ซึ่งคุณสามารถเพิ่มลงในแอปพลิเคชันการฝึกอบรมได้โดยทำการเปลี่ยนแปลงโค้ดเพียงไม่กี่รายการ กลยุทธ์นี้จะสร้างสำเนาของโมเดลใน GPU แต่ละตัวในเครื่อง การอัปเดตเส้นลาดต่อมาจะดำเนินการพร้อมกัน ซึ่งหมายความว่า GPU แต่ละตัวจะคำนวณการส่งผ่านข้อมูลไปข้างหน้าและย้อนกลับผ่านโมเดลในข้อมูลอินพุตที่ต่างกัน จากนั้นระบบจะรวบรวมและหาค่าเฉลี่ยของอนุพันธ์ที่คำนวณจากแต่ละส่วนเหล่านี้ใน GPU ทั้งหมดในกระบวนการที่เรียกว่า all-reduce ระบบจะอัปเดตพารามิเตอร์ของโมเดลโดยใช้การไล่ระดับสีโดยเฉลี่ยเหล่านี้
ส่วนที่ไม่บังคับในตอนท้ายของ Lab ใช้ tf.distribute.MultiWorkerMirroredStrategy ซึ่งคล้ายกับ MirroredStrategy เว้นแต่ว่าเครื่องมือนี้ทำงานได้ในหลายเครื่อง เครื่องแต่ละเครื่องเหล่านี้อาจมี GPU หลายตัวด้วย เช่นเดียวกับ MirroredStrategy MultiWorkerMirroredStrategy เป็นกลยุทธ์การทำงานแบบขนานของข้อมูลแบบซิงค์ที่คุณใช้ได้ด้วยการแก้ไขโค้ดเพียงไม่กี่บรรทัด ความแตกต่างหลักเมื่อเปลี่ยนจากการทำงานแบบขนานของข้อมูลแบบซิงค์ในเครื่องหนึ่งเป็นหลายเครื่องคือตอนนี้ต้องซิงค์ Gradient ที่ส่วนท้ายของแต่ละขั้นตอนใน GPU ทั้งหมดในเครื่องและในเครื่องทั้งหมดในคลัสเตอร์
คุณไม่จำเป็นต้องทราบรายละเอียดเพื่อทําแล็บนี้ให้เสร็จสมบูรณ์ แต่หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทํางานของการฝึกแบบกระจายใน TensorFlow โปรดดูวิดีโอด้านล่าง
4. ตั้งค่าสภาพแวดล้อม
ทําตามขั้นตอนในแล็บการฝึกโมเดลที่กําหนดเองด้วย Vertex AI ให้เสร็จสมบูรณ์เพื่อตั้งค่าสภาพแวดล้อม
5. การฝึกด้วย GPU หลายตัวในเครื่องเดียว
คุณจะส่งงานการฝึกแบบกระจายไปยัง Vertex AI ได้โดยใส่โค้ดแอปพลิเคชันการฝึกในคอนเทนเนอร์ Docker และพุชคอนเทนเนอร์นี้ไปยัง Google Artifact Registry เมื่อใช้วิธีการนี้ คุณจะฝึกโมเดลที่สร้างขึ้นด้วยเฟรมเวิร์กใดก็ได้
เริ่มต้นจากเมนู Launcher ของสมุดบันทึก Workbench ที่คุณสร้างไว้ในห้องทดลองก่อนหน้า ให้เปิดหน้าต่างเทอร์มินัล
ขั้นตอนที่ 1: เขียนโค้ดการฝึก
สร้างไดเรกทอรีใหม่ชื่อ flowers-multi-gpu แล้ว cd เข้าไป
mkdir flowers-multi-gpu
cd flowers-multi-gpu
เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีสำหรับโค้ดการฝึกและไฟล์ Python ที่จะเพิ่มโค้ดด้านล่าง
mkdir trainer
touch trainer/task.py
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี flowers-multi-gpu/ ของคุณ
+ trainer/
+ task.py
จากนั้นเปิดไฟล์ task.py ที่คุณเพิ่งสร้างและคัดลอกโค้ดด้านล่าง
คุณจะต้องแทนที่ {your-gcs-bucket} ใน BUCKET_ROOT ด้วยที่เก็บข้อมูล Cloud Storage ที่คุณจัดเก็บชุดข้อมูลดอกไม้ไว้ในห้องทดลอง 1
import tensorflow as tf
import numpy as np
import os
## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'
# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32
IMG_HEIGHT = 180
IMG_WIDTH = 180
DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
def create_datasets(data_dir, batch_size):
'''Creates train and validation datasets.'''
train_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
validation_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)
return train_dataset, validation_dataset
def create_model():
'''Creates model.'''
model = tf.keras.Sequential([
tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
def main():
# Create distribution strategy
strategy = tf.distribute.MirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap model creation and compilation within scope of strategy
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
model.save(f'{BUCKET_ROOT}/model_output')
if __name__ == "__main__":
main()
ก่อนที่จะสร้างคอนเทนเนอร์ เรามาเจาะลึกโค้ดกัน มีองค์ประกอบเฉพาะสำหรับการใช้การฝึกแบบกระจาย
- ในฟังก์ชัน
main()ระบบจะสร้างออบเจ็กต์MirroredStrategyถัดไป ให้ปิดการสร้างตัวแปรรูปแบบภายในขอบเขตของกลยุทธ์ ขั้นตอนนี้จะบอก TensorFlow ว่าควรมิเรอร์ตัวแปรใดใน GPU - ระบบจะปรับขนาดกลุ่มเป็น
num_replicas_in_syncการปรับขนาดกลุ่มเป็นแนวทางปฏิบัติแนะนำเมื่อใช้กลยุทธ์การทำงานแบบขนานของข้อมูลแบบซิงค์ใน TensorFlow ดูข้อมูลเพิ่มเติมได้ที่นี่
ขั้นตอนที่ 2: สร้าง Dockerfile
หากต้องการบรรจุโค้ดลงในคอนเทนเนอร์ คุณจะต้องสร้าง Dockerfile คุณจะต้องรวมคำสั่งทั้งหมดที่จำเป็นในการเรียกใช้อิมเมจใน Dockerfile ซึ่งจะติดตั้งไลบรารีที่จำเป็นทั้งหมดและตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก
จากเทอร์มินัล ให้สร้าง Dockerfile เปล่าที่รูทของไดเรกทอรี flowers โดยทำดังนี้
touch Dockerfile
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี flowers-multi-gpu/
+ Dockerfile
+ trainer/
+ task.py
เปิด Dockerfile และคัดลอกไฟล์ต่อไปนี้ลงในไฟล์
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
ขั้นตอนที่ 3: สร้างคอนเทนเนอร์
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปร env สำหรับโปรเจ็กต์ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์
PROJECT_ID='your-cloud-project'
สร้างที่เก็บใน Artifact Registry เราจะใช้ที่เก็บที่เราสร้างไว้ในห้องทดลองแรก
REPO_NAME='flower-app'
กําหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Artifact Registry โดยทําดังนี้
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:single_machine
กำหนดค่า Docker
gcloud auth configure-docker \
us-central1-docker.pkg.dev
จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรี flowers-multi-gpu
docker build ./ -t $IMAGE_URI
สุดท้าย ให้พุชไปยัง Artifact Registry โดยทำดังนี้
docker push $IMAGE_URI
เมื่อพุชคอนเทนเนอร์ไปยัง Artifact Registry แล้ว คุณก็พร้อมที่จะเริ่มงานการฝึกแล้ว
ขั้นตอนที่ 4: เรียกใช้งานด้วย SDK
ในส่วนนี้ คุณจะเห็นวิธีกำหนดค่าและเปิดใช้งานงานการฝึกแบบกระจายโดยใช้ Vertex AI Python SDK
สร้างโน้ตบุ๊ก TensorFlow 2 จากตัวเปิด
นําเข้า Vertex AI SDK
from google.cloud import aiplatform
จากนั้นให้กําหนด CustomContainerTrainingJob
คุณจะต้องแทนที่ {PROJECT_ID} ใน container_uri และ {YOUR_BUCKET} ใน staging_bucket
job = aiplatform.CustomContainerTrainingJob(display_name='flowers-multi-gpu',
container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:single_machine',
staging_bucket='gs://{YOUR_BUCKET}')
เมื่อกําหนดงานแล้ว คุณจะเรียกใช้งานได้ คุณตั้งค่าจำนวน Accelerator เป็น 2 หากเราใช้ GPU เพียง 1 ตัว จะไม่ถือว่าเป็นการฝึกแบบกระจาย การฝึกแบบกระจายในเครื่องเดียวคือเมื่อคุณใช้ตัวเร่ง 2 ตัวขึ้นไป
my_custom_job.run(replica_count=1,
machine_type='n1-standard-4',
accelerator_type='NVIDIA_TESLA_V100',
accelerator_count=2)
คุณจะดูความคืบหน้าของงานได้ในคอนโซล
6. [ไม่บังคับ] การฝึกอบรมผู้ปฏิบัติงานหลายคน
เมื่อลองใช้การฝึกแบบกระจายในเครื่องเดียวที่มี GPU หลายตัวแล้ว คุณก็พัฒนาทักษะการฝึกแบบกระจายไปอีกขั้นได้ด้วยการฝึกในเครื่องหลายเครื่อง เราจะไม่เพิ่ม GPU ลงในเครื่องเหล่านั้นเพื่อประหยัดค่าใช้จ่าย แต่คุณอาจทดสอบโดยการเพิ่ม GPU ได้หากต้องการ
เปิดหน้าต่างเทอร์มินัลใหม่ในอินสแตนซ์โน้ตบุ๊ก โดยทำดังนี้
ขั้นตอนที่ 1: เขียนโค้ดการฝึก
สร้างไดเรกทอรีใหม่ชื่อ flowers-multi-machine และเข้ารหัสลงในไดเรกทอรีดังกล่าว:
mkdir flowers-multi-machine
cd flowers-multi-machine
เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีสำหรับโค้ดการฝึกและไฟล์ Python ที่จะเพิ่มโค้ดด้านล่าง
mkdir trainer
touch trainer/task.py
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี flowers-multi-machine/
+ trainer/
+ task.py
จากนั้นให้เปิดไฟล์ task.py ที่คุณเพิ่งสร้างและคัดลอกโค้ดด้านล่าง
คุณจะต้องแทนที่ {your-gcs-bucket} ใน BUCKET_ROOT ด้วยที่เก็บข้อมูล Cloud Storage ที่คุณจัดเก็บชุดข้อมูลดอกไม้ใน Lab 1
import tensorflow as tf
import numpy as np
import os
## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'
# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32
IMG_HEIGHT = 180
IMG_WIDTH = 180
DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
SAVE_MODEL_DIR = f'{BUCKET_ROOT}/multi-machine-output'
def create_datasets(data_dir, batch_size):
'''Creates train and validation datasets.'''
train_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
validation_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)
return train_dataset, validation_dataset
def create_model():
'''Creates model.'''
model = tf.keras.Sequential([
tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
def _is_chief(task_type, task_id):
'''Helper function. Determines if machine is chief.'''
return task_type == 'chief'
def _get_temp_dir(dirpath, task_id):
'''Helper function. Gets temporary directory for saving model.'''
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):
'''Helper function. Gets filepath to save model.'''
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)
def main():
# Create distribution strategy
strategy = tf.distribute.MultiWorkerMirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap variable creation within strategy scope
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
# Determine type and task of the machine from
# the strategy cluster resolver
task_type, task_id = (strategy.cluster_resolver.task_type,
strategy.cluster_resolver.task_id)
# Based on the type and task, write to the desired model path
write_model_path = write_filepath(SAVE_MODEL_DIR, task_type, task_id)
model.save(write_model_path)
if __name__ == "__main__":
main()
ก่อนที่จะสร้างคอนเทนเนอร์ เรามาเจาะลึกโค้ดกัน มีคอมโพเนนต์ 2-3 รายการในโค้ดที่จำเป็นต่อการให้แอปพลิเคชันการฝึกทำงานกับ MultiWorkerMirroredStrategy
- ระบบจะสร้างออบเจ็กต์
MultiWorkerMirroredStrategyในฟังก์ชันmain()ต่อไป ให้คุณรวมการสร้างตัวแปรโมเดลภายในขอบเขตของกลยุทธ์ ขั้นตอนสําคัญนี้บอก TensorFlow ว่าควรมิเรอร์ตัวแปรใดในระบบจำลอง - ระบบจะปรับขนาดกลุ่มเป็น
num_replicas_in_syncแนวทางปฏิบัติแนะนำในการปรับขนาดแบบกลุ่มเป็นแนวทางปฏิบัติแนะนำเมื่อใช้กลยุทธ์การทำงานพร้อมกันของข้อมูลพร้อมกันใน TensorFlow - การบันทึกโมเดลจะซับซ้อนขึ้นเล็กน้อยในกรณีของผู้ปฏิบัติงานหลายคน เนื่องจากปลายทางสำหรับผู้ปฏิบัติงานแต่ละคนต้องไม่เหมือนกัน ผู้ทำงานหลักจะบันทึกลงในไดเรกทอรีโมเดลที่ต้องการ ส่วนผู้ทำงานคนอื่นๆ จะบันทึกโมเดลลงในไดเรกทอรีชั่วคราว สิ่งสำคัญคือไดเรกทอรีชั่วคราวเหล่านี้ต้องไม่ซ้ำกันเพื่อป้องกันไม่ให้ผู้ปฏิบัติงานหลายคนเขียนไปยังตำแหน่งเดียวกัน การบันทึกสามารถประกอบด้วยการดำเนินงานร่วม ซึ่งหมายความว่าผู้ปฏิบัติงานทุกคนต้องประหยัดได้ ไม่ใช่แค่หัวหน้าเท่านั้น ฟังก์ชัน
_is_chief(),_get_temp_dir(),write_filepath()และฟังก์ชันmain()ทั้งหมดมีโค้ดที่ซ้ำกันซึ่งช่วยบันทึกโมเดล
ขั้นตอนที่ 2: สร้าง Dockerfile
หากต้องการบรรจุโค้ดลงในคอนเทนเนอร์ คุณจะต้องสร้าง Dockerfile คุณจะต้องรวมคำสั่งทั้งหมดที่จำเป็นในการเรียกใช้อิมเมจใน Dockerfile ซึ่งจะติดตั้งไลบรารีที่จำเป็นทั้งหมดและตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก
จากเทอร์มินัล ให้สร้าง Dockerfile ที่ว่างเปล่าในรูทของไดเรกทอรีดอกไม้ โดยทำดังนี้
touch Dockerfile
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี flowers-multi-machine/
+ Dockerfile
+ trainer/
+ task.py
เปิด Dockerfile แล้วคัดลอกข้อมูลต่อไปนี้ลงไป
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
ขั้นตอนที่ 3: สร้างคอนเทนเนอร์
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปร env สำหรับโปรเจ็กต์ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์
PROJECT_ID='your-cloud-project'
สร้างที่เก็บใน Artifact Registry เราจะใช้ที่เก็บที่เราสร้างไว้ในห้องทดลองแรก
REPO_NAME='flower-app'
กําหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Google Artifact Registry โดยทําดังนี้
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine
กำหนดค่า Docker
gcloud auth configure-docker \
us-central1-docker.pkg.dev
จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรี flowers-multi-machine
docker build ./ -t $IMAGE_URI
สุดท้าย ให้พุชไปยัง Artifact Registry ดังนี้
docker push $IMAGE_URI
เมื่อพุชคอนเทนเนอร์ไปยัง Artifact Registry แล้ว คุณก็พร้อมที่จะเริ่มงานการฝึกแล้ว
ขั้นตอนที่ 4: เรียกใช้งานด้วย SDK
ในส่วนนี้ คุณจะเห็นวิธีกำหนดค่าและเปิดใช้งานงานการฝึกแบบกระจายโดยใช้ Vertex AI Python SDK
สร้างโน้ตบุ๊ก TensorFlow 2 จากตัวเปิด
นําเข้า Vertex AI SDK
from google.cloud import aiplatform
จากนั้นกำหนด worker_pool_specs
Vertex AI มีพูลผู้ปฏิบัติงาน 4 กลุ่มเพื่อให้ครอบคลุมงานประเภทต่างๆ ในเครื่อง
พูลผู้ปฏิบัติงาน 0 จะกำหนดค่าหลัก หัวหน้า ผู้จัดตารางเวลา หรือ "หลัก" ใน MultiWorkerMirroredStrategy ระบบจะกำหนดให้เครื่องทั้งหมดเป็นผู้ปฏิบัติงาน ซึ่งเป็นเครื่องจริงที่ใช้ดำเนินการคำนวณแบบทำซ้ำ นอกจากเครื่องแต่ละเครื่องจะเป็นเวิร์กเกอร์แล้ว จะต้องมีเวิร์กเกอร์ 1 ตัวที่ทำงานเพิ่มเติม เช่น บันทึกจุดตรวจสอบและเขียนไฟล์ข้อมูลสรุปไปยัง TensorBoard เครื่องนี้ขึ้นชื่อว่าเป็นหัวหน้า มีหัวหน้าผู้ปฏิบัติงานเพียงคนเดียวเท่านั้น ดังนั้นจำนวนผู้ปฏิบัติงานสำหรับพูลผู้ปฏิบัติงาน 0 จึงเป็น 1 เสมอ
พูลผู้ปฏิบัติงาน 1 คือที่ที่คุณกำหนดค่าผู้ปฏิบัติงานเพิ่มเติมสำหรับคลัสเตอร์
พจนานุกรมแรกในรายการ worker_pool_specs แสดงถึงพูลผู้ปฏิบัติงาน 0 และพจนานุกรมที่ 2 แสดงถึงพูลผู้ปฏิบัติงาน 1 ในตัวอย่างนี้ การกําหนดค่า 2 รายการเหมือนกัน แต่หากต้องการฝึกในเครื่อง 3 เครื่อง คุณจะต้องเพิ่มผู้ทํางานไปยังกลุ่มผู้ทํางาน 1 โดยตั้งค่า replica_count เป็น 2 หากต้องการเพิ่ม GPU คุณจะต้องเพิ่มอาร์กิวเมนต์ accelerator_type และ accelerator_count ลงใน machine_spec สำหรับพูลเวิร์กเกอร์ทั้ง 2 กลุ่ม โปรดทราบว่าหากต้องการใช้ GPU กับ MultiWorkerMirroredStrategy เครื่องแต่ละเครื่องในคลัสเตอร์ต้องมี GPU จํานวนเท่ากัน มิฉะนั้น งานจะดำเนินการไม่สำเร็จ
คุณจะต้องแทนที่ {PROJECT_ID} ใน image_uri
# The spec of the worker pools including machine type and Docker image
# Be sure to replace PROJECT_ID in the "image_uri" with your project.
worker_pool_specs=[
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
},
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
}
]
ถัดไป ให้สร้างและเรียกใช้ CustomJob โดยแทนที่ {YOUR_BUCKET} ใน staging_bucket ด้วยที่เก็บข้อมูลในโปรเจ็กต์สำหรับการจัดเตรียม
my_custom_job = aiplatform.CustomJob(display_name='flowers-multi-worker',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
my_custom_job.run()
คุณจะดูความคืบหน้าของงานได้ในคอนโซล
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- เรียกใช้งานการฝึกแบบกระจายด้วย TensorFlow
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ
7. ล้างข้อมูล
เนื่องจากเรากำหนดค่าสมุดบันทึกให้หมดเวลาหลังจากไม่มีการใช้งาน 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่ม "หยุด" ในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม "ลบ"
หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ
