Vertex AI: ใช้การแพ็กเกจอัตโนมัติเพื่อปรับแต่ง Bert ด้วย Hugging Face ในการฝึก Vertex AI
เกี่ยวกับ Codelab นี้
1 ภาพรวม
ในบทแนะนำนี้ คุณจะได้เรียนรู้วิธีเรียกใช้งานการฝึกที่กําหนดเองในการฝึก Vertex AI ด้วยฟีเจอร์การแพ็กเกจอัตโนมัติ งานการฝึกที่กำหนดเองใน Vertex AI ใช้คอนเทนเนอร์ หากไม่ต้องการสร้างอิมเมจของคุณเอง คุณสามารถใช้การบรรจุอัตโนมัติ ซึ่งจะสร้างอิมเมจ Docker ที่กําหนดเองตามโค้ดของคุณ พุชอิมเมจไปยัง Container Registry และเริ่ม CustomJob
ตามอิมเมจ
สิ่งที่คุณเรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้โหมดในเครื่องเพื่อทดสอบโค้ด
- กำหนดค่าและเรียกใช้งานการฝึกที่กำหนดเองด้วย autopackaging
ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ $2
2 ภาพรวมกรณีการใช้งาน
เมื่อใช้ไลบรารีจาก Hugging Face คุณจะปรับแต่งโมเดล Bert ในชุดข้อมูล IMDB ได้ โมเดลจะคาดการณ์ว่ารีวิวภาพยนตร์เป็นเชิงบวกหรือเชิงลบ ระบบจะดาวน์โหลดชุดข้อมูลจากคลังชุดข้อมูลของ Hugging Face และโมเดล Bert จากคลัง Transformers ของ Hugging Face
3 ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
Vertex AI มีผลิตภัณฑ์หลายอย่างเพื่อรองรับเวิร์กโฟลว์ ML ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะเน้นที่การฝึกอบรมและเวิร์กเบนค์
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 Training และช่วยแก้ไขข้อบกพร่องของโค้ดได้ก่อนที่จะทำการเทรนแบบกำหนดเองใน 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 ที่ได้ซึ่งสร้างขึ้นโดยคำสั่ง run ในพื้นที่
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 ระบบจะติดตั้งการพึ่งพาที่เราเพิ่มลงในไฟล์ requirements.txt
ด้วย pip การดำเนินการนี้อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์เมื่อคุณเรียกใช้คำสั่งนี้เป็นครั้งแรก เมื่อสร้างรูปภาพแล้ว ไฟล์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
โดยอิงตามรูปภาพ
กลับไปที่เทอร์มินัลแล้วพิมพ์ cd ขึ้น 1 ระดับเหนือไดเรกทอรี autopkg-codelab
+ autopkg-codelab
+ requirements.txt
+ trainer/
+ task.py
ระบุอิมเมจ TensorFlow GPU ที่สร้างขึ้นล่วงหน้าของ Vertex AI Training เป็นอิมเมจฐานสำหรับงานการฝึกที่กำหนดเอง
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 1 ตัวaccelerator-count
: จำนวน GPU สำหรับ VM แต่ละรายการในพูลผู้ปฏิบัติงานที่จะใช้ โดยค่าเริ่มต้นคือ 1executor-image-uri
: URI ของอิมเมจคอนเทนเนอร์ที่จะเรียกใช้แพ็กเกจที่ระบุ ซึ่งตั้งค่าเป็นอิมเมจฐานของเราlocal-package-path
: เส้นทางในเครื่องของโฟลเดอร์ที่มีโค้ดการฝึกpython-module
: ชื่อโมดูล Python ที่จะเรียกใช้ภายในแพ็กเกจที่ระบุ
เช่นเดียวกับเมื่อคุณเรียกใช้คำสั่งในเครื่อง คุณจะเห็นอิมเมจ Docker กำลังสร้างขึ้น จากนั้นงานการฝึกจะเริ่มต้น ยกเว้นแทนที่คุณจะเห็นเอาต์พุตของงานการฝึก คุณจะเห็นข้อความต่อไปนี้ที่ยืนยันว่างานการฝึกของคุณได้เริ่มต้นแล้ว โปรดทราบว่าเมื่อเรียกใช้คำสั่ง custom-jobs create
เป็นครั้งแรก ระบบอาจใช้เวลา 2-3 นาทีในการสร้างและพุชรูปภาพ
กลับไปที่ส่วนการฝึก Vertex AI ของคอนโซลระบบคลาวด์ และคุณควรเห็นงานกำลังทํางานในส่วนงานที่กำหนดเอง
งานจะใช้เวลาประมาณ 20 นาทีจึงจะเสร็จสมบูรณ์
เมื่อดำเนินการเสร็จแล้ว คุณควรเห็นอาร์ติแฟกต์โมเดลที่บันทึกไว้ต่อไปนี้ในไดเรกทอรี model_output
ในที่เก็บข้อมูล
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- บรรจุโค้ดการฝึกเป็นคอนเทนเนอร์และเรียกใช้ภายในเครื่อง
- ส่งงานการฝึกไปยังการฝึก Vertex AI ด้วยการแพ็กเกจอัตโนมัติ
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ
8 ล้างข้อมูล
เนื่องจากเราได้กำหนดค่าโน้ตบุ๊คให้หมดเวลาหลังจากไม่มีการใช้งานเป็นเวลา 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม "ลบ"
หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ