1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีเรียกใช้งานการฝึกที่กำหนดเองในการฝึก Vertex AI ด้วยฟีเจอร์การสร้างแพ็กเกจอัตโนมัติ งานการฝึกที่กำหนดเองบน Vertex AI ใช้คอนเทนเนอร์ หากไม่ต้องการสร้างอิมเมจของคุณเอง คุณสามารถใช้ Auotpackaging ซึ่งจะสร้างอิมเมจ Docker ที่กําหนดเองตามโค้ดของคุณ จากนั้นพุชอิมเมจไปยัง Container Registry และเริ่ม CustomJob ตามอิมเมจ
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้โหมดภายในเพื่อทดสอบโค้ดของคุณ
- กำหนดค่าและเรียกใช้งานการฝึกที่กำหนดเองด้วย autopackaging
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $2
2. ภาพรวมกรณีการใช้งาน
การใช้ไลบรารีจาก Hugging Face จะช่วยปรับแต่งโมเดล Bert ในชุดข้อมูล IMDB ได้ โมเดลจะคาดการณ์ว่ารีวิวภาพยนตร์เป็นเชิงบวกหรือเชิงลบ ระบบจะดาวน์โหลดชุดข้อมูลจากคลังชุดข้อมูล Hagging Face และโมเดล Bert จากไลบรารีHugging Face Transformers
3. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่จะรวมทั้ง 2 อย่างไว้ใน API เดียว รวมทั้งผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
Vertex AI มีผลิตภัณฑ์ต่างๆ มากมายเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นไปที่การฝึกอบรมและ Workbench
4. ตั้งค่าสภาพแวดล้อมของคุณ
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 3: เปิดใช้ Container Registry API
ไปที่ Container Registry แล้วเลือกเปิดใช้ หากยังไม่ได้เปิด คุณจะใช้ข้อมูลนี้เพื่อสร้างคอนเทนเนอร์สำหรับงานการฝึกที่กำหนดเอง
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench ดังนี้
จากส่วนนั้น ให้คลิกสมุดบันทึกที่มีการจัดการ
จากนั้นเลือกสมุดบันทึกใหม่
ตั้งชื่อสมุดบันทึก แล้วคลิกการตั้งค่าขั้นสูง
ภายใต้การตั้งค่าขั้นสูง ให้เปิดใช้การปิดเมื่อไม่มีการใช้งาน และตั้งค่าจำนวนนาทีเป็น 60 ซึ่งหมายความว่าสมุดบันทึกจะปิดโดยอัตโนมัติเมื่อไม่ได้ใช้งาน คุณจึงไม่จำเป็นต้องมีค่าใช้จ่ายที่ไม่จำเป็น
คุณปล่อยการตั้งค่าขั้นสูงอื่นๆ ทั้งหมดไว้ตามเดิมได้
จากนั้นคลิกสร้าง
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab
ครั้งแรกที่คุณใช้อินสแตนซ์ใหม่ ระบบจะขอให้คุณตรวจสอบสิทธิ์
5. เขียนโค้ดการฝึก
ในการเริ่มต้น จากเมนู Launcher ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์สมุดบันทึก โดยทำดังนี้
สร้างไดเรกทอรีใหม่ชื่อ autopkg-codelab และเข้ารหัสลงในไดเรกทอรีดังกล่าว
mkdir autopkg-codelab
cd autopkg-codelab
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีสำหรับโค้ดการฝึกและไฟล์ Python สำหรับเพิ่มโค้ด
mkdir trainer
touch trainer/task.py
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี autopkg-codelab/ ของคุณ
+ trainer/
+ task.py
จากนั้นให้เปิดไฟล์ task.py ที่คุณเพิ่งสร้างและคัดลอกโค้ดด้านล่าง
import argparse
import tensorflow as tf
from datasets import load_dataset
from transformers import AutoTokenizer
from transformers import TFAutoModelForSequenceClassification
CHECKPOINT = "bert-base-cased"
def get_args():
'''Parses args.'''
parser = argparse.ArgumentParser()
parser.add_argument(
'--epochs',
required=False,
default=3,
type=int,
help='number of epochs')
parser.add_argument(
'--job_dir',
required=True,
type=str,
help='bucket to store saved model, include gs://')
args = parser.parse_args()
return args
def create_datasets():
'''Creates a tf.data.Dataset for train and evaluation.'''
raw_datasets = load_dataset('imdb')
tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
tokenized_datasets = raw_datasets.map((lambda examples: tokenize_function(examples, tokenizer)), batched=True)
# To speed up training, we use only a portion of the data.
# Use full_train_dataset and full_eval_dataset if you want to train on all the data.
small_train_dataset = tokenized_datasets['train'].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_datasets['test'].shuffle(seed=42).select(range(1000))
full_train_dataset = tokenized_datasets['train']
full_eval_dataset = tokenized_datasets['test']
tf_train_dataset = small_train_dataset.remove_columns(['text']).with_format("tensorflow")
tf_eval_dataset = small_eval_dataset.remove_columns(['text']).with_format("tensorflow")
train_features = {x: tf_train_dataset[x] for x in tokenizer.model_input_names}
train_tf_dataset = tf.data.Dataset.from_tensor_slices((train_features, tf_train_dataset["label"]))
train_tf_dataset = train_tf_dataset.shuffle(len(tf_train_dataset)).batch(8)
eval_features = {x: tf_eval_dataset[x] for x in tokenizer.model_input_names}
eval_tf_dataset = tf.data.Dataset.from_tensor_slices((eval_features, tf_eval_dataset["label"]))
eval_tf_dataset = eval_tf_dataset.batch(8)
return train_tf_dataset, eval_tf_dataset
def tokenize_function(examples, tokenizer):
'''Tokenizes text examples.'''
return tokenizer(examples['text'], padding='max_length', truncation=True)
def main():
args = get_args()
train_tf_dataset, eval_tf_dataset = create_datasets()
model = TFAutoModelForSequenceClassification.from_pretrained(CHECKPOINT, num_labels=2)
model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=tf.metrics.SparseCategoricalAccuracy(),
)
model.fit(train_tf_dataset, validation_data=eval_tf_dataset, epochs=args.epochs)
model.save(f'{args.job_dir}/model_output')
if __name__ == "__main__":
main()
สิ่งที่ควรทราบเกี่ยวกับโค้ดมีดังนี้
CHECKPOINTคือโมเดลที่เราต้องการปรับแต่ง ในกรณีนี้ เราใช้ Bert- เมธอด
TFAutoModelForSequenceClassificationจะโหลดสถาปัตยกรรมโมเดลภาษา + น้ำหนักที่ระบุใน TensorFlow แล้วเพิ่มส่วนหัวการแยกประเภทที่ด้านบนพร้อมน้ำหนักเริ่มต้นแบบสุ่ม ในกรณีนี้ เรามีปัญหาในการจำแนกประเภทแบบไบนารี (บวกหรือค่าลบ) เราจึงระบุnum_labels=2สำหรับตัวแยกประเภทนี้
6. สร้างคอนเทนเนอร์และเรียกใช้โค้ดการฝึกในเครื่อง
คุณใช้คำสั่ง gcloud ai custom-jobs local-run เพื่อสร้างอิมเมจคอนเทนเนอร์ Docker ตามโค้ดการฝึกได้ และเรียกใช้อิมเมจเป็นคอนเทนเนอร์ในเครื่องของคุณ การเรียกใช้คอนเทนเนอร์ในเครื่องจะเรียกใช้โค้ดการฝึกในลักษณะเดียวกับที่ทำในการฝึก Vertex AI และช่วยคุณแก้ไขข้อบกพร่องของโค้ดก่อนจะทำการฝึกที่กำหนดเองใน Vertex AI
ในงานการฝึกของเรา เราจะส่งออกโมเดลที่ผ่านการฝึกไปยังที่เก็บข้อมูล Cloud Storage จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปร env สำหรับโปรเจ็กต์ของคุณ และแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์ของคุณ
PROJECT_ID='your-cloud-project'
จากนั้นสร้างที่เก็บข้อมูล หากมีที่เก็บข้อมูลอยู่แล้ว ก็ใช้ที่เก็บข้อมูลดังกล่าวแทนได้เลย
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
เมื่อเราเรียกใช้งานการฝึกที่กำหนดเองในการฝึก Vertex AI เราจะใช้ GPU แต่เนื่องจากเราไม่ได้ระบุอินสแตนซ์ Workbench ด้วย GPU เราจึงจะใช้อิมเมจที่อิงตาม CPU สำหรับการทดสอบในเครื่อง ในตัวอย่างนี้ เราใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของการฝึก Vertex AI
เรียกใช้รายการต่อไปนี้เพื่อตั้งค่า URI ของอิมเมจ Docker เพื่อใช้เป็นฐานของคอนเทนเนอร์
BASE_CPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-7:latest
จากนั้นตั้งชื่อสำหรับอิมเมจ Docker ที่ได้ซึ่งสร้างโดยคำสั่งเรียกใช้ในเครื่อง
OUTPUT_IMAGE=$PROJECT_ID-local-package-cpu:latest
โค้ดการฝึกอบรมของเราใช้ชุดข้อมูล Hugging Face และไลบรารี Transformers ไลบรารีเหล่านี้ไม่รวมอยู่ในรูปภาพที่เราเลือกเป็นอิมเมจฐาน เราจึงจะต้องระบุไลบรารีเหล่านั้นเป็นข้อกำหนด ในการดำเนินการนี้ เราจะสร้างไฟล์ requirements.txt ในไดเรกทอรี autopkg-codelab
ตรวจสอบว่าคุณอยู่ในไดเรกทอรี autopkg-codelab และพิมพ์ข้อมูลต่อไปนี้ในเทอร์มินัล
touch requirements.txt
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี autopkg-codelab ของคุณ
+ requirements.txt
+ trainer/
+ task.py
เปิดไฟล์ข้อกำหนดแล้ววางข้อมูลต่อไปนี้
datasets==1.18.2
transformers==4.16.2
สุดท้าย ให้เรียกใช้คำสั่ง gcloud ai custom-jobs local-run เพื่อเริ่มการฝึกในอินสแตนซ์ที่มีการจัดการของ Workbench
gcloud ai custom-jobs local-run \
--executor-image-uri=$BASE_CPU_IMAGE \
--python-module=trainer.task \
--output-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME
คุณควรเห็นการสร้างอิมเมจ Docker ระบบจะติดตั้งทรัพยากร Dependency ที่เพิ่มลงในไฟล์ requirements.txt การดำเนินการนี้อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์ในครั้งแรกที่คุณเรียกใช้คำสั่งนี้ เมื่อสร้างอิมเมจแล้ว ไฟล์ task.py จะเริ่มทำงานและคุณจะเห็นการฝึกโมเดล คุณควรจะเห็นบางสิ่งเช่นนี้:
เราไม่ได้ใช้ GPU ในเครื่อง การฝึกโมเดลจะใช้เวลานาน คุณกด Ctrl+c และยกเลิกการฝึกอบรมในเครื่องแทนการรอให้งานเสร็จสิ้นได้
โปรดทราบว่าหากต้องการทดสอบเพิ่มเติม คุณก็เรียกใช้อิมเมจที่สร้างด้านบนได้โดยตรงโดยไม่ต้องทำแพ็กเกจใหม่
gcloud beta ai custom-jobs local-run \
--executor-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME \
--epochs=1
7. สร้างงานที่กำหนดเอง
ตอนนี้เราได้ทดสอบโหมดภายในแล้ว เราจะใช้ฟีเจอร์การสร้างแพ็กเกจอัตโนมัติเพื่อเปิดงานการฝึกที่กำหนดเองในการฝึก Vertex AI ด้วยคำสั่งเดียว ฟีเจอร์นี้จะ:
- สร้างอิมเมจ Docker ที่กำหนดเองตามโค้ดของคุณ
- พุชอิมเมจไปยัง Container Registry
- เริ่ม
CustomJobโดยอิงตามรูปภาพ
กลับไปที่เทอร์มินัลแล้วปรับขึ้น 1 ระดับเหนือไดเรกทอรี autopkg-codelab
+ autopkg-codelab
+ requirements.txt
+ trainer/
+ task.py
ระบุอิมเมจ TensorFlow GPU ที่สร้างไว้ล่วงหน้าของการฝึก Vertex AI เป็นอิมเมจฐานสำหรับงานการฝึกที่กำหนดเอง
BASE_GPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-gpu.2-7:latest
จากนั้นเรียกใช้คำสั่ง gcloud ai custom-jobs create ก่อนอื่น คำสั่งนี้จะสร้างอิมเมจ Docker ที่กำหนดเองตามโค้ดการฝึก อิมเมจฐานคือคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของการฝึก Vertex AI ซึ่งเราตั้งค่าเป็น BASE_GPU_IMAGE จากนั้น ฟีเจอร์การจัดแพ็กเกจอัตโนมัติจะติดตั้ง PIP จะติดตั้งชุดข้อมูลและไลบรารี Transformers ที่ระบุไว้ในไฟล์ requirements.txt
gcloud ai custom-jobs create \
--region=us-central1 \
--display-name=fine_tune_bert \
--args=--job_dir=$BUCKET_NAME \
--worker-pool-spec=machine-type=n1-standard-4,replica-count=1,accelerator-type=NVIDIA_TESLA_V100,executor-image-uri=$BASE_GPU_IMAGE,local-package-path=autopkg-codelab,python-module=trainer.task
ลองดูอาร์กิวเมนต์ worker-pool-spec ซึ่งจะกำหนดการกำหนดค่าพูลผู้ปฏิบัติงานที่งานที่กำหนดเองใช้ คุณจะระบุข้อกำหนดของพูลผู้ปฏิบัติงานหลายรายการเพื่อสร้างงานที่กำหนดเองที่มีพูลผู้ปฏิบัติงานหลายรายการสำหรับการฝึกแบบกระจายได้ ในตัวอย่างนี้ เราระบุพูลผู้ปฏิบัติงานเพียงกลุ่มเดียว เนื่องจากโค้ดการฝึกไม่ได้ถูกกำหนดค่าไว้สำหรับการฝึกแบบกระจาย
ช่องหลักๆ ของข้อกำหนดนี้มีดังนี้
machine-type(ต้องระบุ): ประเภทของเครื่อง คลิกที่นี่สำหรับประเภทที่รองรับreplica-count: จำนวนของตัวจำลองผู้ปฏิบัติงานที่จะใช้สำหรับพูลผู้ปฏิบัติงานนี้ ค่าเริ่มต้นคือ 1accelerator-type: ประเภทของ GPU คลิกที่นี่สำหรับประเภทที่รองรับ ในตัวอย่างนี้ เราระบุ GPU NVIDIA Tesla V100 รายการหนึ่งaccelerator-count: จำนวนของ GPU สำหรับ VM แต่ละรายการในพูลผู้ปฏิบัติงานที่จะใช้ โดยค่าเริ่มต้นคือ 1executor-image-uri: URI ของอิมเมจคอนเทนเนอร์ที่เรียกใช้แพ็กเกจที่ระบุ ซึ่งตั้งค่าเป็นอิมเมจฐานของเราlocal-package-path: เส้นทางภายในของโฟลเดอร์ที่มีโค้ดการฝึกpython-module: ชื่อโมดูล Python ที่จะเรียกใช้ภายในแพ็กเกจที่ระบุ
คุณจะเห็นอิมเมจ Docker สร้างขึ้นคล้ายกับเมื่อคุณเรียกใช้คำสั่งในเครื่อง จากนั้นงานการฝึกจะเริ่มต้น ยกเว้นแทนที่คุณจะเห็นเอาต์พุตของงานการฝึก คุณจะเห็นข้อความต่อไปนี้เพื่อยืนยันว่างานการฝึกของคุณได้เริ่มต้นแล้ว โปรดทราบว่าครั้งแรกที่เรียกใช้คำสั่ง custom-jobs create การสร้างและพุชอิมเมจอาจใช้เวลา 2-3 นาที
กลับไปที่ส่วนการฝึก Vertex AI ของ Cloud Console จากนั้นในส่วนงานที่กำหนดเองซึ่งคุณควรจะเห็นงานที่ทำงานอยู่
งานจะใช้เวลาประมาณ 20 นาทีจึงจะเสร็จสมบูรณ์
เมื่อดำเนินการเสร็จแล้ว คุณควรเห็นอาร์ติแฟกต์โมเดลที่บันทึกไว้ต่อไปนี้ในไดเรกทอรี model_output ในที่เก็บข้อมูล
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- สร้างคอนเทนเนอร์และเรียกใช้โค้ดการฝึกในเครื่อง
- ส่งงานการฝึกไปยัง Vertex AI Training ด้วยการสร้างแพ็กเกจอัตโนมัติ
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ
8. ล้างข้อมูล
เนื่องจากเรากำหนดค่าให้สมุดบันทึกหมดเวลาหลังจากไม่มีการใช้งาน 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากคุณต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม ลบ
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
