1. खास जानकारी
इस लैब में, आपको ऑटोपैकिंग की सुविधा की मदद से Vertex AI Training पर कस्टम ट्रेनिंग जॉब चलाने का तरीका पता चलेगा. Vertex AI में कंटेनर का इस्तेमाल करने के लिए, पसंद के मुताबिक बनाई गई ट्रेनिंग जॉब. अगर आपको खुद इमेज नहीं बनानी है, तो ऑटोपैकिंग का इस्तेमाल किया जा सकता है. इससे आपके कोड के आधार पर कस्टम Docker इमेज बन जाएगी. साथ ही, इमेज को Container Registry में पुश कर दिया जाएगा और इमेज के आधार पर CustomJob शुरू हो जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- अपने कोड की जांच करने के लिए, लोकल मोड का इस्तेमाल करें.
- अपने-आप पैकेज बनने की सुविधा की मदद से, कस्टम ट्रेनिंग जॉब को कॉन्फ़िगर और लॉन्च करें.
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $2 है.
2. इस्तेमाल के उदाहरण की खास जानकारी
Hugging Face की लाइब्रेरी का इस्तेमाल करके, IMDB डेटासेट पर Bert मॉडल को बेहतर बनाया जा सकता है. मॉडल यह अनुमान लगाएगा कि फ़िल्म की समीक्षा अच्छी है या बुरी. डेटासेट को Hugging Face डेटासेट लाइब्रेरी से और Bert मॉडल को Hugging Face ट्रांसफ़ॉर्मर लाइब्रेरी से डाउनलोड किया जाएगा.
3. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करता है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML की मदद से ट्रेन किए गए मॉडल और कस्टम मॉडल को अलग-अलग सेवाओं से ऐक्सेस किया जा सकता था. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. मौजूदा प्रोजेक्ट को Vertex AI पर भी माइग्रेट किया जा सकता है. अगर आपका कोई सुझाव, शिकायत या राय है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि एंड-टू-एंड एमएल वर्कफ़्लो को बेहतर बनाया जा सके. इस लैब में ट्रेनिंग और वर्कबेंच पर फ़ोकस किया जाएगा.
4. अपना एनवायरमेंट सेट अप करें
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें.
दूसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.
तीसरा चरण: Container Registry API को चालू करना
कंटेनर रजिस्ट्री पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. इसका इस्तेमाल, कस्टम ट्रेनिंग जॉब के लिए कंटेनर बनाने के लिए किया जाएगा.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
अपने Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:
इसके बाद, मैनेज की गई नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, बेहतर सेटिंग पर क्लिक करें.
बेहतर सेटिंग में जाकर, डिवाइस के इस्तेमाल में न होने पर बंद होने की सुविधा चालू करें. साथ ही, मिनटों की संख्या को 60 पर सेट करें. इसका मतलब है कि इस्तेमाल न किए जाने पर, आपकी notebook अपने-आप बंद हो जाएगी. इससे आपको बेवजह खर्च नहीं करना पड़ेगा.
अन्य सभी बेहतर सेटिंग को पहले जैसा ही रहने दें.
इसके बाद, बनाएं पर क्लिक करें.
इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें.
पहली बार किसी नए इंस्टेंस का इस्तेमाल करने पर, आपसे पुष्टि करने के लिए कहा जाएगा.
5. ट्रेनिंग कोड लिखना
शुरू करने के लिए, अपने नोटबुक इंस्टेंस में, लॉन्चर मेन्यू से Terminal विंडो खोलें:
autopkg-codelab नाम की एक नई डायरेक्ट्री बनाएं और उसमें cd करें.
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वह मॉडल है जिसे हम बेहतर बनाना चाहते हैं. इस मामले में, हम बर्ट की मदद करते हैं.TFAutoModelForSequenceClassificationतरीका, TensorFlow में तय किए गए भाषा मॉडल आर्किटेक्चर + वेट को लोड करेगा. साथ ही, ऊपर से क्लासिफ़िकेशन हेड जोड़ेगा, जिसमें वेट को रैंडम तरीके से शुरू किया जाएगा. इस मामले में, हमारे पास बाइनरी क्लासिफ़िकेशन (पॉज़िटिव या नेगेटिव) की समस्या है. इसलिए, हम इस क्लासिफ़ायर के लिएnum_labels=2तय करते हैं.
6. ट्रेनिंग कोड को कंटेनर में डालना और उसे लोकल तौर पर चलाना
अपने ट्रेनिंग कोड के आधार पर Docker कंटेनर इमेज बनाने के लिए, gcloud ai custom-jobs local-run कमांड का इस्तेमाल किया जा सकता है. साथ ही, इमेज को अपनी लोकल मशीन पर कंटेनर के तौर पर चलाया जा सकता है. स्थानीय तौर पर कंटेनर चलाने पर, आपका ट्रेनिंग कोड उसी तरह से चलता है जिस तरह Vertex AI Training पर चलता है. साथ ही, Vertex AI पर कस्टम ट्रेनिंग करने से पहले, अपने कोड की समस्याओं को डीबग करने में भी मदद मिलती है.
ट्रेनिंग जॉब में, हम अपने ट्रेन किए गए मॉडल को Cloud Storage बकेट में एक्सपोर्ट करेंगे. अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, अपने टर्मिनल में यह तरीका अपनाएं. your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डालना न भूलें:
PROJECT_ID='your-cloud-project'
इसके बाद, एक बकेट बनाएं. अगर आपके पास पहले से कोई बकेट है, तो उसका इस्तेमाल करें.
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Vertex AI Training पर कस्टम ट्रेनिंग जॉब चलाने पर, हम जीपीयू का इस्तेमाल करेंगे. हालांकि, हमने अपने Workbench इंस्टेंस के लिए जीपीयू का इस्तेमाल नहीं किया है. इसलिए, हम स्थानीय टेस्टिंग के लिए सीपीयू पर आधारित इमेज का इस्तेमाल करेंगे. इस उदाहरण में, हम Vertex AI Training के पहले से बने कंटेनर का इस्तेमाल करते हैं.
कंटेनर के बेस के तौर पर इस्तेमाल करने के लिए, 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 के डेटासेट और ट्रांसफ़ॉर्मर लाइब्रेरी का इस्तेमाल करता है. हमने अपनी बेस इमेज के तौर पर जो इमेज चुनी है उसमें ये लाइब्रेरी शामिल नहीं हैं. इसलिए, हमें इन्हें ज़रूरी शर्तों के तौर पर उपलब्ध कराना होगा. इसके लिए, हम अपनी autopkg-codelab डायरेक्ट्री में requirements.txt फ़ाइल बनाएंगे.
पक्का करें कि आप autopkg-codelab डायरेक्ट्री में हों और अपने टर्मिनल में यह लिखें.
touch requirements.txt
अब आपको अपनी autopkg-codelab डायरेक्ट्री में ये चीज़ें दिखनी चाहिए:
+ requirements.txt
+ trainer/
+ task.py
ज़रूरी फ़ाइल खोलें और यहां चिपकाएं
datasets==1.18.2
transformers==4.16.2
आखिर में, हमारे Workbench की मदद से मैनेज किए जा रहे इंस्टेंस पर ट्रेनिंग शुरू करने के लिए, gcloud ai custom-jobs local-run कमांड लागू करें.
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 Training पर अपनी कस्टम ट्रेनिंग जॉब लॉन्च करने के लिए, ऑटोपैकिंग की सुविधा का इस्तेमाल करेंगे. एक ही कमांड से, यह सुविधा:
- अपने कोड के आधार पर कस्टम Docker इमेज बनाएं.
- इमेज को कंटेनर रजिस्ट्री में पुश करें.
- इमेज के आधार पर
CustomJobशुरू करें.
टर्मिनल पर वापस जाएं और cd up का इस्तेमाल करके, अपनी autopkg-codelab डायरेक्ट्री से एक लेवल ऊपर जाएं.
+ autopkg-codelab
+ requirements.txt
+ trainer/
+ task.py
मनमुताबिक ट्रेनिंग जॉब के लिए, पहले से बनी TensorFlow जीपीयू इमेज को 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 Training का पहले से बना कंटेनर है, जिसे हमने BASE_GPU_IMAGE के तौर पर सेट किया है. इसके बाद, डेटासेट और ट्रांसफ़ॉर्मर लाइब्रेरी को, हमारी 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: जीपीयू का टाइप. इस्तेमाल किए जा सकने वाले टाइप के बारे में जानने के लिए, यहां क्लिक करें. इस उदाहरण में, हमने एक NVIDIA Tesla V100 जीपीयू तय किया है.accelerator-count: वर्कर्स पूल में मौजूद हर वर्चुअल मशीन के लिए, इस्तेमाल किए जाने वाले जीपीयू की संख्या. डिफ़ॉल्ट रूप से, इसकी वैल्यू 1 होती है.executor-image-uri: उस कंटेनर इमेज का यूआरआई जो दिए गए पैकेज को चलाएगा. यह हमारी बेस इमेज पर सेट है.local-package-path: उस फ़ोल्डर का लोकल पाथ जिसमें ट्रेनिंग कोड मौजूद है.python-module: दिए गए पैकेज में चलाए जाने वाले Python मॉड्यूल का नाम.
स्थानीय कमांड चलाने की तरह ही, आपको Docker इमेज बनते हुए दिखेगी. इसके बाद, ट्रेनिंग जॉब शुरू हो जाएगी. हालांकि, ट्रेनिंग जॉब का आउटपुट देखने के बजाय, आपको यह मैसेज दिखेगा. इससे यह पुष्टि होगी कि आपकी ट्रेनिंग जॉब लॉन्च हो गई है. ध्यान दें कि पहली बार custom-jobs create कमांड चलाने पर, इमेज को बनाने और उसे पुश करने में कुछ मिनट लग सकते हैं.
Cloud Console के Vertex AI Training सेक्शन पर वापस जाएं. इसके बाद, कस्टम जॉब में जाकर, आपको अपना जॉब चलता हुआ दिखेगा.
इस प्रोसेस को पूरा होने में करीब 20 मिनट लगेंगे.
प्रोसेस पूरी होने के बाद, आपको अपनी बकेट में model_output डायरेक्ट्री में ये सेव किए गए मॉडल आर्टफ़ैक्ट दिखेंगे.
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके, ये काम करने का तरीका जाना है:
- ट्रेनिंग कोड को कंटेनर में डालना और उसे लोकल तौर पर चलाना
- अपने-आप पैकेज होने की सुविधा की मदद से, Vertex AI Training में ट्रेनिंग जॉब सबमिट करना
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, यह दस्तावेज़ पढ़ें.
8. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक कोई गतिविधि न होने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने के बारे में चिंता करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, 'बंद करें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें:
