1. खास जानकारी
इस लैब में, आपको ऑटोपैकेजिंग की सुविधा की मदद से Vertex AI Training पर कस्टम ट्रेनिंग जॉब चलाने का तरीका बताया जाएगा. Vertex AI में कंटेनर का इस्तेमाल करने के लिए, पसंद के मुताबिक बनाई गई ट्रेनिंग जॉब. अगर आपको अपनी इमेज नहीं बनानी है, तो auotप्रॉडक्टेज का इस्तेमाल किया जा सकता है. यह आपके कोड के आधार पर पसंद के मुताबिक Docker इमेज बनाएगा, फिर इमेज को कंटेनर रजिस्ट्री में पुश करेगा, और इमेज के आधार पर CustomJob को शुरू करेगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- अपने कोड की जांच करने के लिए, लोकल मोड का इस्तेमाल करें.
- ऑटोपैकेजिंग की मदद से, ज़रूरत के मुताबिक ट्रेनिंग जॉब कॉन्फ़िगर करें और लॉन्च करें.
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $2 है.
2. इस्तेमाल के उदाहरण की खास जानकारी
हगिंग फ़ेस की लाइब्रेरी का इस्तेमाल करके, आईएमडीबी डेटासेट पर बर्ट मॉडल को बेहतर तरीके से ट्यून किया जा सकता है. मॉडल यह अनुमान लगाएगा कि किसी फ़िल्म की समीक्षा सकारात्मक है या नकारात्मक. यह डेटासेट, Hugging Face डेटासेट की लाइब्रेरी से और Hugging Face ट्रांसफ़ॉर्मर लाइब्रेरी से बर्ट के मॉडल से डाउनलोड किया जाएगा.
3. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. 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. ट्रेनिंग कोड में बदलाव करने की अनुमति दें
शुरू करने के लिए, लॉन्चर मेन्यू में जाकर, अपने notebook के इंस्टेंस में टर्मिनल विंडो खोलें:
autopkg-codelab नाम की एक नई डायरेक्ट्री बनाएं और उसमें सीडी करें.
mkdir autopkg-codelab
cd autopkg-codelab
अपने Terminal से, ट्रेनिंग कोड और 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 बकेट में एक्सपोर्ट करेंगे. अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, अपने Terminal से, इसे चलाएं और your-cloud-project को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:
PROJECT_ID='your-cloud-project'
इसके बाद, एक बकेट बनाएं. अगर आपके पास कोई मौजूदा बकेट है, तो उसका इस्तेमाल करें.
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Vertex AI Training में, ज़रूरत के मुताबिक बनाई गई ट्रेनिंग के लिए हम जीपीयू का इस्तेमाल करेंगे. हालांकि, हमने जीपीयू के साथ अपने वर्कबेंच इंस्टेंस के बारे में जानकारी नहीं दी है. इसलिए, हम लोकल टेस्टिंग के लिए, सीपीयू पर आधारित इमेज का इस्तेमाल करेंगे. इस उदाहरण में, हमने Vertex AI की ट्रेनिंग के लिए पहले से बने कंटेनर का इस्तेमाल किया है.
कंटेनर के बेस के तौर पर इस्तेमाल करने के लिए, 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
हमारा ट्रेनिंग कोड, हगिंग फ़ेस डेटासेट और ट्रांसफ़ॉर्मर लाइब्रेरी का इस्तेमाल करता है. ये लाइब्रेरी उस इमेज में शामिल नहीं हैं जिसे हमने हमारी बेस इमेज के तौर पर चुना है. इसलिए, हमें इन्हें ज़रूरी शर्तों के तौर पर उपलब्ध कराना होगा. ऐसा करने के लिए, हम अपनी 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 फ़ाइल में जिन डिपेंडेंसी को जोड़ा है उन्हें पीआईपी (पिक्चर में पिक्चर) इंस्टॉल किया जाएगा. पहली बार इस निर्देश को लागू करने में कुछ मिनट लग सकते हैं. इमेज बनने के बाद, task.py फ़ाइल चलने लगेगी. साथ ही, आपको मॉडल ट्रेनिंग दिखेगी. आपको कुछ ऐसा दिखेगा:
हम जीपीयू का इस्तेमाल स्थानीय तौर पर नहीं कर रहे हैं. इसलिए, मॉडल ट्रेनिंग में ज़्यादा समय लगेगा. काम पूरा होने का इंतज़ार करने के बजाय, आपके पास Ctrl+c और लोकल ट्रेनिंग को रद्द करने का विकल्प है.
ध्यान दें कि अगर आपको और जांच करनी है, तो रीपैकेजिंग के बिना भी ऊपर बनाई गई इमेज को सीधे चलाया जा सकता है.
gcloud beta ai custom-jobs local-run \
--executor-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME \
--epochs=1
7. पसंद के मुताबिक जॉब बनाएं
हमने लोकल मोड की टेस्टिंग कर ली है. इसलिए, अब हम Vertex AI की ट्रेनिंग के लिए कस्टम ट्रेनिंग जॉब को लॉन्च करने के लिए, ऑटोपैकेजिंग की सुविधा का इस्तेमाल करेंगे. एक निर्देश से, यह सुविधा:
- अपने कोड के आधार पर, पसंद के मुताबिक Docker इमेज बनाएं.
- इमेज को कंटेनर रजिस्ट्री में भेजें.
- इमेज के हिसाब से
CustomJobबनाएं.
टर्मिनल पर वापस जाएं और अपनी 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: इस वर्कर पूल के लिए, वर्कर की बनाई गई कॉपी की संख्या के लिए डिफ़ॉल्ट रूप से वैल्यू एक होती है.accelerator-type: जीपीयू के टाइप. समर्थित प्रकारों के लिए यहां क्लिक करें. इस उदाहरण में, हमने एक NVIDIA Tesla V100 जीपीयू बताया है.accelerator-count: वर्कर पूल में हर वीएम के लिए जीपीयू की संख्या, डिफ़ॉल्ट रूप से एक वैल्यू होती है.executor-image-uri: कंटेनर इमेज का यूआरआई, जो दिए गए पैकेज को चलाएगा. यह हमारी बेस इमेज पर सेट है.local-package-path: ट्रेनिंग कोड वाले फ़ोल्डर का लोकल पाथ.python-module: दिए गए पैकेज में चलाने के लिए Python मॉड्यूल का नाम.
जिस तरह जब आपने लोकल कमांड चलाया, उसी तरह से Docker इमेज बनाई जाती है और फिर ट्रेनिंग का काम शुरू हो जाता है. ट्रेनिंग जॉब का आउटपुट देखने के बजाय, आपको यह मैसेज दिखेगा कि ट्रेनिंग जॉब लॉन्च हो गई है या नहीं. ध्यान दें कि पहली बार custom-jobs create निर्देश चलाने पर, इमेज बनने और उसे पुश होने में कुछ मिनट लग सकते हैं.
Cloud Console के Vertex AI सकें ट्रेनिंग सेक्शन पर वापस जाएं. इसके बाद, कस्टम जॉब में जाकर, आपको अपनी नौकरी दिखती है.
इस काम को पूरा होने में करीब 20 मिनट लगेंगे.
सेट अप पूरा होने के बाद, आपको अपने बकेट की model_output डायरेक्ट्री में, सेव किए गए मॉडल के ये आर्टफ़ैक्ट दिखेंगे.
🎉 बधाई हो! 🎉
आपने Vertex AI को इस्तेमाल करने का तरीका जान लिया है, ताकि:
- ट्रेनिंग कोड को स्थानीय तौर पर कंटेनर में बदलें और चलाएं
- ऑटोपैकेजिंग की मदद से, Vertex AI Training में ट्रेनिंग जॉब सबमिट करें
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, यह दस्तावेज़ पढ़ें.
8. साफ़-सफ़ाई सेवा
हमने notebook को इस तरह से कॉन्फ़िगर किया है कि उसका समय 60 मिनट बाद बंद हो जाए. इसलिए, हमें इंस्टेंस बंद होने की चिंता करने की ज़रूरत नहीं है. अगर आपको मैन्युअल तरीके से इंस्टेंस शट डाउन करना है, तो कंसोल के Vertex AI Workbench सेक्शन में, 'रोकें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
