Vertex AI: Vertex AI की ट्रेनिंग के दौरान, गले मिलते हुए चेहरे के साथ बर्ट को बेहतर बनाने के लिए, ऑटोपैकेजिंग का इस्तेमाल करें

1. खास जानकारी

इस लैब में, आपको ऑटोपैकेजिंग सुविधा के साथ Vertex AI Training पर कस्टम ट्रेनिंग जॉब चलाने का तरीका बताया जाएगा. Vertex AI पर कस्टम ट्रेनिंग जॉब के लिए कंटेनर का इस्तेमाल किया जाता है. अगर आपको अपनी इमेज नहीं बनानी है, तो ऑटोपैकेजिंग का इस्तेमाल किया जा सकता है. यह आपके कोड के आधार पर, पसंद के मुताबिक Docker इमेज बनाएगी. साथ ही, इमेज को Container Registry में पुश करेगी और इमेज के आधार पर CustomJob शुरू करेगी.

आपको ये सब सीखने को मिलेगा

आपको, इनके बारे में जानकारी मिलेगी:

• अपने कोड की जांच करने के लिए, लोकल मोड का इस्तेमाल करें.
• ऑटोपैकेजिंग की मदद से, ट्रेनिंग के लिए पसंद के मुताबिक बनाए गए जॉब को कॉन्फ़िगर करें और लॉन्च करें.

Google Cloud पर इस लैब को चलाने की कुल लागत करीब 2 डॉलर है.

2. इस्तेमाल के उदाहरण की खास जानकारी

Hugging Face की लाइब्रेरी का इस्तेमाल करके, IMDB डेटासेट पर Bert मॉडल को फ़ाइन ट्यून किया जाएगा. यह मॉडल, फ़िल्म की समीक्षाओं के आधार पर यह अनुमान लगाएगा कि वे सकारात्मक हैं या नकारात्मक. डेटासेट को Hugging Face datasets library से डाउनलोड किया जाएगा. साथ ही, Bert मॉडल को Hugging Face transformers library से डाउनलोड किया जाएगा.

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 चालू करना

Container Registry पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. इसका इस्तेमाल, कस्टम ट्रेनिंग जॉब के लिए कंटेनर बनाने के लिए किया जाएगा.

चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना

Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:

इसके बाद, मैनेज किए गए नोटबुक पर क्लिक करें:

इसके बाद, नई नोटबुक चुनें.

अपनी नोटबुक को कोई नाम दें. इसके बाद, बेहतर सेटिंग पर क्लिक करें.

ऐडवांस सेटिंग में जाकर, डिवाइस के बंद होने की सुविधा चालू करें. इसके बाद, डिवाइस के बंद होने का समय 60 मिनट पर सेट करें. इसका मतलब है कि इस्तेमाल न किए जाने पर, आपकी नोटबुक अपने-आप बंद हो जाएगी, ताकि आपको बिना वजह शुल्क न देना पड़े.

अन्य सभी ऐडवांस सेटिंग को डिफ़ॉल्ट रूप से सेट रहने दें.

इसके बाद, बनाएं पर क्लिक करें.

इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें.

पहली बार किसी नए इंस्टेंस का इस्तेमाल करते समय, आपसे पुष्टि करने के लिए कहा जाएगा.

5. ट्रेनिंग कोड लिखना

शुरू करने के लिए, लॉन्चर मेन्यू से अपने नोटबुक इंस्टेंस में टर्मिनल विंडो खोलें:

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 वह मॉडल है जिसे हमें बेहतर बनाना है. इस मामले में, हम Bert का इस्तेमाल करते हैं.
• TFAutoModelForSequenceClassification तरीके से, TensorFlow में बताए गए भाषा मॉडल आर्किटेक्चर + वज़न लोड किए जाएंगे. साथ ही, ऊपर की ओर क्लासिफ़िकेशन हेड जोड़ा जाएगा, जिसमें वज़न को रैंडम तरीके से शुरू किया जाएगा. इस मामले में, हमारे पास बाइनरी क्लासिफ़िकेशन की समस्या है (पॉज़िटिव या नेगेटिव). इसलिए, हम इस क्लासिफ़ायर के लिए num_labels=2 तय करते हैं.

6. ट्रेनिंग कोड को कंटेनर में रखें और उसे स्थानीय तौर पर चलाएं

gcloud ai custom-jobs local-run कमांड का इस्तेमाल करके, ट्रेनिंग कोड के आधार पर Docker कंटेनर इमेज बनाई जा सकती है. साथ ही, इमेज को अपने कंप्यूटर पर कंटेनर के तौर पर चलाया जा सकता है. कंटेनर को स्थानीय तौर पर चलाने से, ट्रेनिंग कोड उसी तरह से काम करता है जिस तरह से वह Vertex AI Training पर काम करता है. इससे, Vertex AI पर कस्टम ट्रेनिंग करने से पहले, कोड से जुड़ी समस्याओं को ठीक करने में मदद मिल सकती है.

ट्रेनिंग जॉब में, हम अपने ट्रेन किए गए मॉडल को Cloud Storage बकेट में एक्सपोर्ट करेंगे. अपने टर्मिनल से, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, यहां दिया गया कमांड चलाएं. साथ ही, यह पक्का करें कि आपने your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डाला हो:

अपने टर्मिनल में gcloud config list --format 'value(core.project)' चलाकर, प्रोजेक्ट आईडी पाया जा सकता है

PROJECT_ID='your-cloud-project'

इसके बाद, एक बकेट बनाएं. अगर आपके पास पहले से कोई बकेट है, तो उसका इस्तेमाल करें.

BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME

Vertex AI Training पर कस्टम ट्रेनिंग जॉब चलाने के दौरान, हम जीपीयू का इस्तेमाल करेंगे. हालांकि, हमने अपने Workbench इंस्टेंस में GPU के बारे में नहीं बताया है. इसलिए, हम स्थानीय टेस्टिंग के लिए सीपीयू पर आधारित इमेज का इस्तेमाल करेंगे. इस उदाहरण में, हम 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

आखिर में, 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 Training पर कस्टम ट्रेनिंग जॉब लॉन्च करने के लिए, ऑटोपैकेजिंग सुविधा का इस्तेमाल करेंगे. एक कमांड से, यह सुविधा ये काम करेगी:

• अपने कोड के आधार पर कस्टम डॉकर इमेज बनाएं.
• इमेज को Container Registry में पुश करें.
• इमेज के आधार पर CustomJob शुरू करें.

टर्मिनल पर वापस जाएं और autopkg-codelab डायरेक्ट्री से एक लेवल ऊपर जाएं.

+ autopkg-codelab
  + requirements.txt
  + trainer/
      + task.py

कस्टम ट्रेनिंग जॉब के लिए, Vertex AI Training की पहले से तैयार की गई TensorFlow GPU इमेज को बेस इमेज के तौर पर सेट करें.

BASE_GPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-gpu.2-7:latest

इसके बाद, gcloud ai custom-jobs create कमांड चलाएं. सबसे पहले, यह निर्देश ट्रेनिंग कोड के आधार पर कस्टम डॉकर इमेज बनाएगा. बेस इमेज, Vertex AI Training का पहले से बना हुआ कंटेनर है. इसे हमने BASE_GPU_IMAGE के तौर पर सेट किया है. इसके बाद, ऑटोपैकेजिंग की सुविधा, हमारी requirements.txt फ़ाइल में बताए गए डेटासेट और ट्रांसफ़ॉर्मर लाइब्रेरी को pip install करेगी.

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 कमांड चलाने पर, इमेज को बनने और पुश होने में कुछ मिनट लग सकते हैं.

क्लाउड कंसोल के Vertex AI Training सेक्शन पर वापस जाएं. आपको CUSTOM JOBS में अपना जॉब चलता हुआ दिखेगा.

इस प्रोसेस को पूरा होने में करीब 20 मिनट लगेंगे.

प्रोसेस पूरी होने के बाद, आपको अपने बकेट में मौजूद model_output डायरेक्ट्री में, सेव किए गए मॉडल के ये आर्टफ़ैक्ट दिखेंगे.

🎉 बधाई हो! 🎉

आपने Vertex AI का इस्तेमाल करके ये काम करने का तरीका सीखा है:

• ट्रेनिंग कोड को कंटेनर में रखें और उसे स्थानीय तौर पर चलाएं
• ऑटोपैकजिंग की सुविधा के साथ, Vertex AI Training में ट्रेनिंग जॉब सबमिट करना

Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

8. साफ़-सफ़ाई सेवा

हमने नोटबुक को 60 मिनट तक इस्तेमाल न किए जाने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, Stop बटन पर क्लिक करें. अगर आपको नोटबुक पूरी तरह से मिटानी है, तो 'मिटाएं' बटन पर क्लिक करें.

स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें: