Vertex AI: ใช้การจัดแพ็กเกจอัตโนมัติเพื่อปรับแต่ง Bert ด้วยการกอดใบหน้าในการฝึก Vertex AI

Vertex AI:
ใช้การแพ็กเกจอัตโนมัติเพื่อปรับแต่ง Bert ด้วย Hugging Face ในการฝึก Vertex AI

เกี่ยวกับ Codelab นี้

subjectอัปเดตล่าสุดเมื่อ ก.พ. 4, 2022
account_circleเขียนโดย Nikita Namjoshi

1 ภาพรวม

ในบทแนะนำนี้ คุณจะได้เรียนรู้วิธีเรียกใช้งานการฝึกที่กําหนดเองในการฝึก Vertex AI ด้วยฟีเจอร์การแพ็กเกจอัตโนมัติ งานการฝึกที่กำหนดเองใน Vertex AI ใช้คอนเทนเนอร์ หากไม่ต้องการสร้างอิมเมจของคุณเอง คุณสามารถใช้การบรรจุอัตโนมัติ ซึ่งจะสร้างอิมเมจ Docker ที่กําหนดเองตามโค้ดของคุณ พุชอิมเมจไปยัง Container Registry และเริ่ม CustomJob ตามอิมเมจ

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน 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 ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะเน้นที่การฝึกอบรมและเวิร์กเบนค์

ภาพรวมผลิตภัณฑ์ Vertex

4 ตั้งค่าสภาพแวดล้อม

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้

ขั้นตอนที่ 2: เปิดใช้ Vertex AI API

ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API

แดชบอร์ด Vertex AI

ขั้นตอนที่ 3: เปิดใช้ Container Registry API

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

ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench

จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench

เมนู Vertex AI

จากตรงนั้น ให้คลิกโน้ตบุ๊กที่มีการจัดการ

Notebooks_UI

จากนั้นเลือกสมุดบันทึกใหม่

new_notebook

ตั้งชื่อโน้ตบุ๊ก แล้วคลิกการตั้งค่าขั้นสูง

create_notebook

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

idle_timeout

คุณปล่อยการตั้งค่าขั้นสูงอื่นๆ ทั้งหมดไว้ตามเดิมได้

จากนั้นคลิกสร้าง

เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab

open_jupyterlab

ครั้งแรกที่คุณใช้อินสแตนซ์ใหม่ ระบบจะขอให้คุณตรวจสอบสิทธิ์

ตรวจสอบสิทธิ์

5 เขียนโค้ดการฝึก

ในการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์โน้ตบุ๊กจากเมนู Launcher โดยทำดังนี้

launcher_terminal

สร้างไดเรกทอรีใหม่ชื่อ 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จะเริ่มทํางานและคุณจะเห็นการฝึกโมเดล คุณควรเห็นข้อมูลในลักษณะนี้

local_training

เนื่องจากเราไม่ได้ใช้ 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: จำนวนของตัวจำลองผู้ปฏิบัติงานที่จะใช้สำหรับพูลผู้ปฏิบัติงานนี้ ค่าเริ่มต้นคือ 1
  • accelerator-type: ประเภท GPU คลิกที่นี่เพื่อดูประเภทที่รองรับ ในตัวอย่างนี้ เราระบุ GPU NVIDIA Tesla V100 1 ตัว
  • accelerator-count: จำนวน GPU สำหรับ VM แต่ละรายการในพูลผู้ปฏิบัติงานที่จะใช้ โดยค่าเริ่มต้นคือ 1
  • executor-image-uri: URI ของอิมเมจคอนเทนเนอร์ที่จะเรียกใช้แพ็กเกจที่ระบุ ซึ่งตั้งค่าเป็นอิมเมจฐานของเรา
  • local-package-path: เส้นทางในเครื่องของโฟลเดอร์ที่มีโค้ดการฝึก
  • python-module: ชื่อโมดูล Python ที่จะเรียกใช้ภายในแพ็กเกจที่ระบุ

เช่นเดียวกับเมื่อคุณเรียกใช้คำสั่งในเครื่อง คุณจะเห็นอิมเมจ Docker กำลังสร้างขึ้น จากนั้นงานการฝึกจะเริ่มต้น ยกเว้นแทนที่คุณจะเห็นเอาต์พุตของงานการฝึก คุณจะเห็นข้อความต่อไปนี้ที่ยืนยันว่างานการฝึกของคุณได้เริ่มต้นแล้ว โปรดทราบว่าเมื่อเรียกใช้คำสั่ง custom-jobs create เป็นครั้งแรก ระบบอาจใช้เวลา 2-3 นาทีในการสร้างและพุชรูปภาพ

training_started

กลับไปที่ส่วนการฝึก Vertex AI ของคอนโซลระบบคลาวด์ และคุณควรเห็นงานกำลังทํางานในส่วนงานที่กำหนดเอง

training_job

งานจะใช้เวลาประมาณ 20 นาทีจึงจะเสร็จสมบูรณ์

เมื่อดำเนินการเสร็จแล้ว คุณควรเห็นอาร์ติแฟกต์โมเดลที่บันทึกไว้ต่อไปนี้ในไดเรกทอรี model_output ในที่เก็บข้อมูล

model_output

🎉 ยินดีด้วย 🎉

คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว

  • บรรจุโค้ดการฝึกเป็นคอนเทนเนอร์และเรียกใช้ภายในเครื่อง
  • ส่งงานการฝึกไปยังการฝึก Vertex AI ด้วยการแพ็กเกจอัตโนมัติ

ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ

8 ล้างข้อมูล

เนื่องจากเราได้กำหนดค่าโน้ตบุ๊คให้หมดเวลาหลังจากไม่มีการใช้งานเป็นเวลา 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม "ลบ"

ลบ

หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ

ลบพื้นที่เก็บข้อมูล