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

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

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 बकेट का नाम डालना होगा जिसमें आपने Lab 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 को यह बताया जाता है कि किन वैरिएबल को सभी GPU में कॉपी किया जाना चाहिए.
• बैच के साइज़ को num_replicas_in_sync के हिसाब से बढ़ाया जाता है. TensorFlow में सिंक्रोनस डेटा पैरललिज़्म की रणनीतियों का इस्तेमाल करते समय, बैच साइज़ को बढ़ाना सबसे सही तरीका है. आपको यहां ज़्यादा जानकारी मिल सकती है.

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

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

अपने टर्मिनल से, flowers डायरेक्ट्री के रूट में एक खाली 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"]

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

अपने टर्मिनल से, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, यहां दिया गया कमांड चलाएं. साथ ही, यह पक्का करें कि आपने 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

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

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 में पुश करने के बाद, अब ट्रेनिंग जॉब शुरू की जा सकती है.

चौथा चरण: एसडीके की मदद से जॉब चलाना

इस सेक्शन में, 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 पर सेट करनी होगी. अगर हम सिर्फ़ एक GPU का इस्तेमाल करते हैं, तो इसे डिस्ट्रिब्यूटेड ट्रेनिंग नहीं माना जाएगा. एक ही मशीन पर डिस्ट्रिब्यूटेड ट्रेनिंग का मतलब है कि दो या उससे ज़्यादा ऐक्सलरेटर का इस्तेमाल किया जा रहा है.

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

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

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

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

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

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

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

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 बकेट का नाम डालना होगा जिसमें आपने Lab 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 का इस्तेमाल किया है, तो हो सकता है कि आपने MultiWorkerMirroredStrategy एनवायरमेंट वैरिएबल सेट अप किया हो.TF_CONFIG Vertex AI, TF_CONFIG को आपके लिए अपने-आप सेट करता है. इसलिए, आपको अपने क्लस्टर में मौजूद हर मशीन पर इस वैरिएबल को तय करने की ज़रूरत नहीं है.

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

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

अपने टर्मिनल से, flowers डायरेक्ट्री के रूट में एक खाली 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"]

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

अपने टर्मिनल से, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, यहां दिया गया कमांड चलाएं. साथ ही, यह पक्का करें कि आपने 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

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

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 में पुश करने के बाद, अब ट्रेनिंग जॉब शुरू की जा सकती है.

चौथा चरण: एसडीके की मदद से जॉब चलाना

इस सेक्शन में, 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 को दिखाती है. इस सैंपल में, दोनों कॉन्फ़िगरेशन एक जैसे हैं. हालांकि, अगर आपको तीन मशीनों पर ट्रेनिंग देनी है, तो वर्कर पूल 1 में अतिरिक्त वर्कर जोड़ें. इसके लिए, replica_count को 2 पर सेट करें. अगर आपको जीपीयू जोड़ने हैं, तो आपको दोनों वर्कर पूल के लिए 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"}
      }
          ]

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

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. साफ़-सफ़ाई सेवा

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

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