प्रोटोटाइप टू प्रोडक्शन: Vertex AI की मदद से कस्टम मॉडल को ट्रेनिंग देना

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

इस लैब में, कस्टम ट्रेनिंग जॉब चलाने के लिए Vertex AI का इस्तेमाल किया जाएगा.

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

.

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

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

• Vertex AI Workbench की मदद से मैनेज किया जा रहा नोटबुक बनाना
• Vertex AI के यूज़र इंटरफ़ेस (यूआई) से, पसंद के मुताबिक ट्रेनिंग देने की सुविधा को कॉन्फ़िगर करना और लॉन्च करना
• Vertex AI Python SDK की मदद से, पसंद के मुताबिक ट्रेनिंग देने का जॉब कॉन्फ़िगर करना और उसे लॉन्च करना

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

2. Vertex AI के बारे में जानकारी

इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है.

Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: ट्रेनिंग और वर्कबेंच

3. अपना एनवायरमेंट सेट अप करने का तरीका

इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.

पहला चरण: Compute Engine API चालू करना

Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें.

दूसरा चरण: Artifact Registry API चालू करना

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

तीसरा चरण: Vertex AI API चालू करना

Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.

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

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

अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.

चालू होने के बाद, मैनेज की गई नोटबुक पर क्लिक करें:

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

अपनी नोटबुक को कोई नाम दें. इसके बाद, अनुमति में जाकर सेवा खाता चुनें

ऐडवांस सेटिंग को चुनें.

अगर सुरक्षा में जाकर "टर्मिनल चालू करें" विकल्प पहले से चालू नहीं है, तो इसे चालू करें.

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

इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस को चालू होने में कुछ मिनट लगेंगे.

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

4. ट्रेनिंग ऐप्लिकेशन कोड को कंटेनर में रखना

आपको इस ट्रेनिंग जॉब को Vertex AI में सबमिट करना होगा. इसके लिए, आपको अपने ट्रेनिंग ऐप्लिकेशन के कोड को Docker कंटेनर में डालना होगा. इसके बाद, इस कंटेनर को Google Artifact Registry में पुश करना होगा. इस तरीके का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.

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

पहला चरण: Cloud Storage बकेट बनाना

इस ट्रेनिंग जॉब में, आपको ट्रेन किए गए TensorFlow मॉडल को Cloud Storage बकेट में एक्सपोर्ट करना होगा. ट्रेनिंग के लिए डेटा को Cloud Storage बकेट में भी सेव किया जाएगा.

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

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

PROJECT_ID='your-cloud-project'

इसके बाद, अपने प्रोजेक्ट में नया बकेट बनाने के लिए, अपने टर्मिनल में यह कमांड चलाएं.

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

दूसरा चरण: डेटा को Cloud Storage बकेट में कॉपी करना

हमें अपने फूलों के डेटासेट को Cloud Storage में डालना है. उदाहरण के तौर पर, सबसे पहले इस Workbench इंस्टेंस में डेटासेट डाउनलोड करें. इसके बाद, इसे बकेट में कॉपी करें.

डेटा डाउनलोड करें और उसे अनटार करें.

wget https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
tar xvzf flower_photos.tgz

इसके बाद, इसे उस बकेट में कॉपी करें जिसे आपने अभी बनाया है. हमने -r इसलिए जोड़ा है, क्योंकि हमें पूरी डायरेक्ट्री कॉपी करनी है. साथ ही, हमने -m इसलिए जोड़ा है, ताकि मल्टी-प्रोसेसिंग कॉपी की जा सके. इससे प्रोसेस तेज़ी से पूरी होगी.

gsutil -m cp -r flower_photos $BUCKET

तीसरा चरण: ट्रेनिंग कोड लिखना

flowers नाम की नई डायरेक्ट्री बनाएं और उसमें cd करें:

mkdir flowers
cd flowers

ट्रेनिंग कोड के लिए डायरेक्ट्री और एक Python फ़ाइल बनाने के लिए, यहां दिया गया कोड चलाएं. इस फ़ाइल में आपको कोड जोड़ना होगा.

mkdir trainer
touch trainer/task.py

अब आपकी flowers/ डायरेक्ट्री में ये फ़ाइलें होनी चाहिए:

+ trainer/
    + task.py

ट्रेनिंग ऐप्लिकेशन कोड को स्ट्रक्चर करने के तरीके के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

इसके बाद, अभी बनाई गई task.py फ़ाइल खोलें और नीचे दिए गए कोड को कॉपी करें.

आपको {your-gcs-bucket} की जगह, Cloud Storage की उस बकेट का नाम डालना होगा जिसे आपने अभी बनाया है.

Cloud Storage FUSE टूल की मदद से, Vertex AI Training पर ट्रेनिंग के लिए इस्तेमाल किए जाने वाले जॉब, Cloud Storage पर मौजूद डेटा को लोकल फ़ाइल सिस्टम में फ़ाइलों के तौर पर ऐक्सेस कर सकते हैं. कस्टम ट्रेनिंग का काम शुरू करने पर, यह काम /gcs डायरेक्ट्री को देखता है. इसमें आपके सभी Cloud Storage बकेट, सबडायरेक्ट्री के तौर पर मौजूद होते हैं. इसलिए, ट्रेनिंग कोड में डेटा पाथ /gcs से शुरू होते हैं.

import tensorflow as tf
import numpy as np
import os

## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'

# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32

IMG_HEIGHT = 180
IMG_WIDTH = 180

DATA_DIR = f'{BUCKET_ROOT}/flower_photos'

def create_datasets(data_dir, batch_size):
  '''Creates train and validation datasets.'''
  
  train_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  validation_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
  validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)

  return train_dataset, validation_dataset


def create_model():
  '''Creates model.'''

  model = tf.keras.Sequential([
    tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
    tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
    tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
  ])
  return model

# CREATE DATASETS
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)

# CREATE/COMPILE MODEL
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(),
              metrics=['accuracy'])

# TRAIN MODEL
history = model.fit(
  train_dataset,
  validation_data=validation_dataset,
  epochs=EPOCHS
)

# SAVE MODEL
model.save(f'{BUCKET_ROOT}/model_output')

चौथा चरण: Dockerfile बनाना

अपने कोड को कंटेनर में रखने के लिए, आपको एक Dockerfile बनाना होगा. Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी कमांड शामिल करें. इससे सभी ज़रूरी लाइब्रेरी इंस्टॉल हो जाएंगी और ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप हो जाएगा.

अपने टर्मिनल से, flowers डायरेक्ट्री के रूट में एक खाली Dockerfile बनाएं:

touch Dockerfile

अब आपकी flowers/ डायरेक्ट्री में ये फ़ाइलें होनी चाहिए:

+ Dockerfile
+ trainer/
    + task.py

Dockerfile खोलें और इसमें यह कोड कॉपी करें:

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8

WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]

आइए, इस फ़ाइल में मौजूद निर्देशों की समीक्षा करें.

FROM कमांड, बेस इमेज के बारे में बताती है. यह पैरंट इमेज होती है, जिस पर आपकी बनाई गई इमेज आधारित होगी. बेस इमेज के तौर पर, Deep Learning Container TensorFlow Enterprise 2.8 GPU Docker इमेज का इस्तेमाल किया जाएगा. Google Cloud पर मौजूद डीप लर्निंग कंटेनर में, एमएल और डेटा साइंस के कई सामान्य फ़्रेमवर्क पहले से इंस्टॉल होते हैं.

WORKDIR कमांड, इमेज पर मौजूद उस डायरेक्ट्री के बारे में बताती है जहां बाद के निर्देश चलाए जाते हैं.

COPY निर्देश, ट्रेनर कोड को Docker इमेज में कॉपी करता है. ध्यान दें कि इस उदाहरण में, हमारे पास ट्रेनर डायरेक्ट्री में सिर्फ़ एक Python फ़ाइल है. हालांकि, ज़्यादा सटीक उदाहरण के लिए, आपके पास अतिरिक्त फ़ाइलें होंगी. ऐसा हो सकता है कि एक को data.py कहा जाए, जो डेटा प्रीप्रोसेसिंग को हैंडल करता है. वहीं, दूसरे को model.py कहा जाए, जिसमें सिर्फ़ मॉडल कोड वगैरह होता है. ट्रेनिंग के ज़्यादा जटिल कोड के लिए, Python प्रोजेक्ट को पैकेज करने के बारे में Python के दस्तावेज़ देखें.

अगर आपको कोई और लाइब्रेरी जोड़नी है, तो pip install (उदाहरण के लिए: RUN pip install -r requirements.txt) के लिए RUN कमांड का इस्तेमाल किया जा सकता है. हालांकि, यहां दिए गए उदाहरण के लिए हमें किसी और लाइब्रेरी की ज़रूरत नहीं है.

आखिर में, ENTRYPOINT कमांड, ट्रेनर को शुरू करने के लिए एंट्री पॉइंट सेट अप करती है. ट्रेनिंग का काम शुरू करने पर, यह कोड चलेगा. हमारे मामले में, यह task.py फ़ाइल को एक्ज़ीक्यूट कर रहा है.

Vertex AI Training के लिए Dockerfile लिखने के बारे में ज़्यादा जानने के लिए, यहां जाएं.

चौथा चरण: कंटेनर बनाना

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

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

PROJECT_ID='your-cloud-project'

Artifact Registry में कोई रेपो बनाना

REPO_NAME='flower-app'

gcloud artifacts repositories create $REPO_NAME --repository-format=docker \
--location=us-central1 --description="Docker repository"

Google Artifact Registry में मौजूद कंटेनर इमेज के यूआरआई के साथ एक वैरिएबल तय करें:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image:latest

Docker को कॉन्फ़िगर करना

gcloud auth configure-docker \
    us-central1-docker.pkg.dev

इसके बाद, flower डायरेक्ट्री के रूट से यह कमांड चलाकर कंटेनर बनाएं:

docker build ./ -t $IMAGE_URI

आखिर में, इसे Artifact Registry में पुश करें:

docker push $IMAGE_URI

कंटेनर को Artifact Registry में पुश करने के बाद, अब ट्रेनिंग जॉब शुरू की जा सकती है.

5. Vertex AI पर कस्टम ट्रेनिंग जॉब चलाना

इस लैब में, Google Artifact Registry पर मौजूद कस्टम कंटेनर के ज़रिए कस्टम ट्रेनिंग का इस्तेमाल किया गया है. हालांकि, पहले से बनाए गए कंटेनर का इस्तेमाल करके भी ट्रेनिंग जॉब चलाई जा सकती है.

शुरू करने के लिए, Cloud Console के Vertex सेक्शन में मौजूद ट्रेनिंग सेक्शन पर जाएं:

पहला चरण: ट्रेनिंग जॉब कॉन्फ़िगर करना

ट्रेनिंग जॉब के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें.

• डेटासेट में जाकर, कोई मैनेज किया गया डेटासेट नहीं चुनें
• इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (ऐडवांस) चुनें और जारी रखें पर क्लिक करें.
• नया मॉडल ट्रेन करें को चुनें. इसके बाद, मॉडल का नाम के लिए flowers-model डालें. इसके अलावा, अपने मॉडल के लिए कोई भी नाम डाला जा सकता है
• जारी रखें पर क्लिक करें

कंटेनर की सेटिंग वाले चरण में, कस्टम कंटेनर चुनें:

पहले बॉक्स (कंटेनर इमेज) में, पिछले सेक्शन से अपने IMAGE_URI वैरिएबल की वैल्यू डालें. यह us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image:latest होना चाहिए. इसमें आपका प्रोजेक्ट आईडी शामिल होना चाहिए. बाकी फ़ील्ड को खाली छोड़ दें और जारी रखें पर क्लिक करें.

जारी रखें पर फिर से क्लिक करके, हाइपरपैरामीटर वाले चरण को छोड़ें.

दूसरा चरण: कंप्यूट क्लस्टर कॉन्फ़िगर करना

वर्कर पूल 0 को इस तरह कॉन्फ़िगर करें:

फ़िलहाल, आपको छठे चरण को छोड़ना होगा. इस सीरीज़ के अगले लैब में, अनुमान लगाने वाले कंटेनर को कॉन्फ़िगर करें.

ट्रेनिंग जॉब शुरू करने के लिए, ट्रेनिंग शुरू करें पर क्लिक करें. आपको अपनी कंसोल के ट्रेनिंग सेक्शन में, ट्रेनिंग पाइपलाइन टैब में, नई लॉन्च की गई नौकरी दिखेगी:

ट्रेनिंग जॉब को पूरा होने में करीब 10 मिनट लगेंगे.

🎉 बधाई हो! 🎉

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

• कस्टम कंटेनर में दिए गए ट्रेनिंग कोड के लिए, कस्टम ट्रेनिंग जॉब लॉन्च करें. इस उदाहरण में, TensorFlow मॉडल का इस्तेमाल किया गया है. हालांकि, कस्टम या पहले से मौजूद कंटेनर का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.

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

6. [ज़रूरी नहीं] Vertex AI Python SDK का इस्तेमाल करना

पिछले सेक्शन में, यूज़र इंटरफ़ेस (यूआई) के ज़रिए ट्रेनिंग जॉब लॉन्च करने का तरीका बताया गया था. इस सेक्शन में, Vertex AI Python SDK का इस्तेमाल करके ट्रेनिंग जॉब सबमिट करने का दूसरा तरीका बताया गया है.

अपने नोटबुक इंस्टेंस पर वापस जाएं और लॉन्चर से TensorFlow 2 नोटबुक बनाएं:

Vertex AI SDK इंपोर्ट करें.

from google.cloud import aiplatform

इसके बाद, CustomContainerTrainingJob बनाएं. आपको {PROJECT_ID} में मौजूद {PROJECT_ID} की जगह अपने प्रोजेक्ट का नाम डालना होगा. साथ ही, staging_bucket में मौजूद {BUCKET} की जगह, पहले बनाया गया बकेट डालना होगा.container_uri

my_job = aiplatform.CustomContainerTrainingJob(display_name='flower-sdk-job',
                                               container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image:latest',
                                               staging_bucket='gs://{BUCKET}')

इसके बाद, नौकरी ढूंढें.

my_job.run(replica_count=1,
           machine_type='n1-standard-8',
           accelerator_type='NVIDIA_TESLA_V100',
           accelerator_count=1)

उदाहरण के तौर पर, इस जॉब को पिछले सेक्शन की तुलना में बड़े कंप्यूटर पर चलाने के लिए कॉन्फ़िगर किया गया है. इसके अलावा, हम GPU का इस्तेमाल कर रहे हैं. अगर आपने machine-type, accelerator_type या accelerator_count की जानकारी नहीं दी है, तो जॉब डिफ़ॉल्ट रूप से n1-standard-4 पर चलेगी.

आपको अपनी कंसोल के ट्रेनिंग सेक्शन में, CUSTOM JOBS टैब में ट्रेनिंग जॉब दिखेगी.

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

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

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