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

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

इस लैब में, आपको TensorFlow का इस्तेमाल करके, Vertex AI Training में डिस्ट्रिब्यूट की जाने वाली ट्रेनिंग के लिए Vertex AI का इस्तेमाल करना होगा.

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

.

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

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

• एक से ज़्यादा जीपीयू वाली एक मशीन पर डिस्ट्रिब्यूटेड ट्रेनिंग चलाएं
• अलग-अलग मशीनों पर डिस्ट्रिब्यूटेड ट्रेनिंग चलाएं

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

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

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

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

3. डिस्ट्रिब्यूटेड ट्रेनिंग की खास जानकारी

अगर आपके पास एक ही जीपीयू है, तो TensorFlow, इस ऐक्सेलरेटर का इस्तेमाल करके मॉडल ट्रेनिंग की रफ़्तार को तेज़ करेगा. इसके लिए आपको अलग से कुछ नहीं करना होगा. हालांकि, अगर एक से ज़्यादा जीपीयू के इस्तेमाल से आपको और ज़्यादा फ़ायदा चाहिए, तो आपको tf.distribute का इस्तेमाल करना होगा. यह TensorFlow का मॉड्यूल है, जिसकी मदद से अलग-अलग डिवाइसों पर कंप्यूटेशन की जांच की जा सकती है.

इस लैब के पहले सेक्शन में, tf.distribute.MirroredStrategy का इस्तेमाल किया जाता है. इसे कोड में कुछ बदलाव करके, ट्रेनिंग ऐप्लिकेशन में जोड़ा जा सकता है. इस रणनीति से, आपके डिवाइस पर मौजूद हर जीपीयू पर मॉडल की एक कॉपी बन जाती है. बाद के ग्रेडिएंट अपडेट सिंक्रोनस तरीके से होंगे. इसका मतलब है कि हर जीपीयू, इनपुट डेटा के अलग-अलग स्लाइस के आधार पर, मॉडल से होते हुए फ़ॉरवर्ड और बैकवर्ड पास की गणना करता है. इसके बाद, इनमें से हर स्लाइस के कंप्यूट किए गए ग्रेडिएंट सभी जीपीयू के लिए एग्रीगेट किए जाते हैं और इसका औसत तौर पर all-reduce कहा जाता है. मॉडल पैरामीटर, इन औसत ग्रेडिएंट का इस्तेमाल करके अपडेट किए जाते हैं.

लैब के आखिर में मौजूद वैकल्पिक सेक्शन में tf.distribute.MultiWorkerMirroredStrategy का इस्तेमाल किया जाता है, जो MirroredStrategy की तरह है. हालांकि, यह एक से ज़्यादा मशीनों के साथ काम करता है. इनमें से हर एक मशीन में एक से ज़्यादा जीपीयू भी हो सकते हैं. जैसे, MirroredStrategy, MultiWorkerMirroredStrategy एक सिंक्रोनस डेटा पैरलिज़्म रणनीति है, जिसका इस्तेमाल कोड में कुछ ही बदलाव करके किया जा सकता है. एक मशीन पर सिंक्रोनस डेटा पैरलिज़्म से कई मशीन पर जाने पर मुख्य अंतर यह है कि अब हर चरण के आखिर में ग्रेडिएंट को मशीन में और क्लस्टर की सभी मशीन में सभी जीपीयू के साथ सिंक करने की ज़रूरत है.

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

4. अपना एनवायरमेंट सेट अप करें

अपना एनवायरमेंट सेट अप करने के लिए, Vertex AI की मदद से कस्टम मॉडल की ट्रेनिंग लैब में दिए गए चरणों को पूरा करें.

5. एक मशीन, एक से ज़्यादा जीपीयू की ट्रेनिंग

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

शुरू करने के लिए, पिछली लैब में बनाई गई वर्कबेंच नोटबुक के लॉन्चर मेन्यू से टर्मिनल विंडो खोलें.

पहला चरण: ट्रेनिंग कोड लिखना

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

mkdir flowers-multi-gpu
cd flowers-multi-gpu

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

mkdir trainer
touch trainer/task.py

अब आपकी flowers-multi-gpu/ डायरेक्ट्री में यह जानकारी होनी चाहिए:

+ trainer/
    + task.py

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

आपको BUCKET_ROOT में {your-gcs-bucket} को Cloud Storage बकेट से बदलना होगा, जहां आपने लैब 1 में फूलों का डेटासेट सेव किया था.

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

def main():  

  # Create distribution strategy
  strategy = tf.distribute.MirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)

  # Wrap model creation and compilation within scope of strategy
  with strategy.scope():
    model = create_model()
    model.compile(optimizer=tf.keras.optimizers.Adam(),
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                  metrics=['accuracy'])

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

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


if __name__ == "__main__":
    main()

कंटेनर बनाने से पहले, आइए कोड को गहराई से समझें. डिस्ट्रिब्यूटेड ट्रेनिंग का इस्तेमाल करने के लिए, कुछ कॉम्पोनेंट खास तौर पर उपलब्ध होते हैं.

• main() फ़ंक्शन में, MirroredStrategy ऑब्जेक्ट बनाया जाता है. इसके बाद, मॉडल वैरिएबल बनाने की सुविधा को रणनीति के स्कोप में शामिल करें. इस चरण से TensorFlow को पता चलता है कि सभी जीपीयू में कौनसे वैरिएबल डुप्लीकेट होने चाहिए.
• बैच का साइज़, num_replicas_in_sync के हिसाब से बढ़ाया गया है. TensorFlow में सिंक्रोनस डेटा पैरलिज़्म रणनीतियों का इस्तेमाल करते समय बैच साइज़ को स्केल करना सबसे सही तरीका है. आपको यहां ज़्यादा जानकारी मिल सकती है.

दूसरा चरण: Dockerfile बनाएं

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

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

touch Dockerfile

अब आपकी flowers-multi-gpu/ डायरेक्ट्री में यह जानकारी होनी चाहिए:

+ 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"]

तीसरा चरण: कंटेनर बनाना

अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, अपने Terminal से, इसे चलाएं और your-cloud-project को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:

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

PROJECT_ID='your-cloud-project'

Artifact Registry में, डेटा स्टोर करने की सुविधा का रेपो बनाएं. हम पहले लैब में बनाए गए रेपो का इस्तेमाल करेंगे.

REPO_NAME='flower-app'

Artifact Registry में, अपनी कंटेनर इमेज के यूआरआई के साथ वैरिएबल तय करें:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:single_machine

डॉकर कॉन्फ़िगर करें

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

इसके बाद, अपनी flowers-multi-gpu डायरेक्ट्री के रूट से नीचे दिए गए निर्देशों को चलाकर कंटेनर बनाएं:

docker build ./ -t $IMAGE_URI

आखिर में, उसे Artifact Registry में भेजें:

docker push $IMAGE_URI

Artifact Registry में भेजे गए कंटेनर के बाद, अब आप ट्रेनिंग की शुरुआत करने के लिए तैयार हैं.

चरण 4: SDK टूल की मदद से जॉब चलाएं

इस सेक्शन में, Vertex AI Python SDK टूल का इस्तेमाल करके, डिस्ट्रिब्यूटेड ट्रेनिंग जॉब को कॉन्फ़िगर और लॉन्च करने का तरीका बताया गया है.

लॉन्चर से, TensorFlow 2 नोटबुक बनाएं.

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

from google.cloud import aiplatform

इसके बाद, CustomContainerTrainingJob तय करें.

आपको container_uri में {PROJECT_ID} और staging_bucket में {YOUR_BUCKET} को बदलना होगा.

job = aiplatform.CustomContainerTrainingJob(display_name='flowers-multi-gpu',
                                            container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:single_machine',
                                            staging_bucket='gs://{YOUR_BUCKET}')

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

my_custom_job.run(replica_count=1,
                  machine_type='n1-standard-4',
                  accelerator_type='NVIDIA_TESLA_V100',
                  accelerator_count=2)

कंसोल में, आपको अपने काम की प्रोग्रेस दिखेगी.

6. [ज़रूरी नहीं] एक से ज़्यादा कर्मचारियों के लिए ट्रेनिंग

अब आपने अलग-अलग जीपीयू वाले एक ही मशीन पर, डिस्ट्रिब्यूट किए जाने वाले ट्रेनिंग की सुविधा आज़मा ली है. अब अलग-अलग मशीनों पर ट्रेनिंग करके, अपने छात्र-छात्राओं को दी जाने वाली ट्रेनिंग के कौशल को और बेहतर बनाया जा सकता है. लागत कम रखने के लिए, हम उन मशीनों में कोई जीपीयू नहीं जोड़ेंगे. हालांकि, अगर आप चाहें, तो जीपीयू जोड़कर एक्सपेरिमेंट किया जा सकता है.

अपने notebook के इंस्टेंस में नई टर्मिनल विंडो खोलें:

पहला चरण: ट्रेनिंग कोड लिखना

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

mkdir flowers-multi-machine
cd flowers-multi-machine

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

mkdir trainer
touch trainer/task.py

अब आपकी flowers-multi-machine/ डायरेक्ट्री में यह जानकारी होनी चाहिए:

+ trainer/
    + task.py

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

आपको BUCKET_ROOT में {your-gcs-bucket} को Cloud Storage बकेट से बदलना होगा, जहां आपने लैब 1 में फूलों का डेटासेट सेव किया था.

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'
SAVE_MODEL_DIR = f'{BUCKET_ROOT}/multi-machine-output'

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

def _is_chief(task_type, task_id):
  '''Helper function. Determines if machine is chief.'''

  return task_type == 'chief'


def _get_temp_dir(dirpath, task_id):
  '''Helper function. Gets temporary directory for saving model.'''

  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir


def write_filepath(filepath, task_type, task_id):
  '''Helper function. Gets filepath to save model.'''

  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

def main():
  # Create distribution strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model()
    model.compile(optimizer=tf.keras.optimizers.Adam(),
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                  metrics=['accuracy'])

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

  # Determine type and task of the machine from
  # the strategy cluster resolver
  task_type, task_id = (strategy.cluster_resolver.task_type,
                        strategy.cluster_resolver.task_id)

  # Based on the type and task, write to the desired model path
  write_model_path = write_filepath(SAVE_MODEL_DIR, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

कंटेनर बनाने से पहले, आइए कोड को गहराई से समझें. कोड में कुछ कॉम्पोनेंट होते हैं, जो ट्रेनिंग ऐप्लिकेशन को MultiWorkerMirroredStrategy के साथ काम करने के लिए ज़रूरी होते हैं.

• main() फ़ंक्शन में, MultiWorkerMirroredStrategy ऑब्जेक्ट बनाया जाता है. इसके बाद, मॉडल वैरिएबल बनाने की सुविधा को रणनीति के स्कोप में शामिल करें. इस अहम चरण से TensorFlow का पता चलता है कि सभी प्रतियों में कौनसे वैरिएबल डुप्लीकेट होने चाहिए.
• बैच का साइज़, num_replicas_in_sync के हिसाब से बढ़ाया गया है. TensorFlow में सिंक्रोनस डेटा पैरलिज़्म रणनीतियों का इस्तेमाल करते समय बैच साइज़ को स्केल करना सबसे सही तरीका है.
• बहु-कर्मचारी मामले में अपने मॉडल को सहेजना कुछ अधिक जटिल है क्योंकि प्रत्येक कर्मियों के लिए गंतव्य भिन्न होना चाहिए. मुख्य वर्कर को अपनी पसंद की मॉडल डायरेक्ट्री में सेव करना होगा, जबकि दूसरे वर्कर मॉडल को अस्थायी डायरेक्ट्री में सेव करेंगे. यह ज़रूरी है कि ये अस्थायी डायरेक्ट्री यूनीक हों, ताकि कई काम करने वाले लोग एक ही जगह पर न लिखें. बचत करने के लिए सामूहिक कार्रवाइयां भी की जा सकती हैं. इसका मतलब है कि सिर्फ़ अधिकारी को ही नहीं, बल्कि सभी कर्मचारियों को भी बचाना होगा. _is_chief(), _get_temp_dir(), write_filepath(), और main() फ़ंक्शन में बॉयलरप्लेट कोड शामिल होता है, जो मॉडल को सेव करने में मदद करता है.

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

दूसरा चरण: Dockerfile बनाएं

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

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

touch Dockerfile

अब आपकी flowers-multi-machine/ डायरेक्ट्री में यह जानकारी होनी चाहिए:

+ 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"]

तीसरा चरण: कंटेनर बनाना

अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, अपने Terminal से, इसे चलाएं और your-cloud-project को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:

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

PROJECT_ID='your-cloud-project'

Artifact Registry में, डेटा स्टोर करने की सुविधा का रेपो बनाएं. हम पहले लैब में बनाए गए रेपो का इस्तेमाल करेंगे.

REPO_NAME='flower-app'

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

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine

डॉकर कॉन्फ़िगर करें

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

इसके बाद, अपनी flowers-multi-machine डायरेक्ट्री के रूट से नीचे दिए गए निर्देशों को चलाकर कंटेनर बनाएं:

docker build ./ -t $IMAGE_URI

आखिर में, उसे Artifact Registry में भेजें:

docker push $IMAGE_URI

Artifact Registry में भेजे गए कंटेनर के बाद, अब आप ट्रेनिंग की शुरुआत करने के लिए तैयार हैं.

चरण 4: SDK टूल की मदद से जॉब चलाएं

इस सेक्शन में, Vertex AI Python SDK टूल का इस्तेमाल करके, डिस्ट्रिब्यूटेड ट्रेनिंग जॉब को कॉन्फ़िगर और लॉन्च करने का तरीका बताया गया है.

लॉन्चर से, TensorFlow 2 नोटबुक बनाएं.

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

from google.cloud import aiplatform

इसके बाद, worker_pool_specs तय करें.

Vertex AI में अलग-अलग तरह के मशीन से होने वाले टास्क को पूरा करने के लिए, चार वर्कर पूल उपलब्ध हैं.

वर्कर पूल 0, प्राइमरी, चीफ़, शेड्यूलर या "मास्टर" को कॉन्फ़िगर करता है. MultiWorkerMirroredStrategy में, सभी मशीनों को वर्कर के तौर पर दर्ज किया जाता है. ये ऐसी फ़िज़िकल मशीन होती हैं जिन पर डुप्लीकेट कंप्यूटेशन इस्तेमाल किया जाता है. हर मशीन के काम करने के अलावा, एक कर्मचारी की ज़रूरत होती है, जो कुछ और काम भी करे. जैसे, चेकपॉइंट सेव करना और TensorBoard में खास जानकारी वाली फ़ाइलें लिखना. इस मशीन को चीफ़ के नाम से जाना जाता है. काम का सिर्फ़ एक मुख्य कर्मचारी होता है. इसलिए, वर्कर पूल 0 के लिए आपके वर्कर की संख्या हमेशा 1 होगी.

वर्कर पूल 1 में, अपने क्लस्टर के लिए अतिरिक्त वर्कर कॉन्फ़िगर किए जाते हैं.

worker_pool_specs सूची की पहली डिक्शनरी, वर्कर पूल 0 के बारे में बताती है और दूसरी डिक्शनरी, वर्कर पूल 1 के बारे में बताती है. इस सैंपल में, दोनों कॉन्फ़िगरेशन एक जैसे हैं. हालांकि, अगर आपको तीन मशीनों के बीच ट्रेनिंग करनी है, तो replica_count को 2 पर सेट करके, वर्कर पूल 1 में अतिरिक्त वर्कर को जोड़ना होगा. अगर आपको जीपीयू जोड़ने हैं, तो आपको दोनों वर्कर पूल के लिए, machine_spec में accelerator_type और accelerator_count आर्ग्युमेंट जोड़ने होंगे. ध्यान दें कि अगर आपको MultiWorkerMirroredStrategy के साथ जीपीयू का इस्तेमाल करना है, तो क्लस्टर में हर मशीन में एक जैसी संख्या में जीपीयू होने चाहिए. ऐसा न होने पर काम पूरा नहीं होगा.

आपको image_uri में, {PROJECT_ID} को बदलना होगा.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace PROJECT_ID in the "image_uri" with your project.

worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-4",
        },
        "container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-4",
        },
        "container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
      }
          ]

इसके बाद, स्टेजिंग के लिए अपने प्रोजेक्ट में staging_bucket में {YOUR_BUCKET} को बकेट से बदलकर, CustomJob बनाएं और चलाएं.

my_custom_job = aiplatform.CustomJob(display_name='flowers-multi-worker',
                                     worker_pool_specs=worker_pool_specs,
                                     staging_bucket='gs://{YOUR_BUCKET}')

my_custom_job.run()

कंसोल में, आपको अपने काम की प्रोग्रेस दिखेगी.

🎉 बधाई हो! 🎉

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

• TensorFlow की मदद से, डिस्ट्रिब्यूटेड ट्रेनिंग जॉब चलाएं

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

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

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

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