Vertex AI: डिस्ट्रिब्यूटेड हाइपर पैरामीटर ट्यूनिंग

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

इस लैब में, आपको हाइपर पैरामीटर ट्यूनिंग और डिस्ट्रिब्यूटेड ट्रेनिंग के लिए, Vertex AI का इस्तेमाल करने का तरीका बताया जाएगा. यह लैब, मॉडल कोड के लिए TensorFlow का इस्तेमाल करती है, लेकिन ये सिद्धांत अन्य एमएल फ़्रेमवर्क पर भी लागू होते हैं.

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

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

• कस्टम कंटेनर पर डिस्ट्रिब्यूटेड ट्रेनिंग का इस्तेमाल करके, मॉडल को ट्रेन करना
• अपने-आप हाइपरपैरामीटर ट्यूनिंग करने के लिए, ट्रेनिंग कोड के कई ट्रायल लॉन्च करना

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

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

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

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

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

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

हाइपर पैरामीटर ट्यूनिंग

Vertex AI ट्रेनिंग की मदद से, हाइपरपैरामीटर ट्यूनिंग, आपके चुने गए हाइपरपैरामीटर की वैल्यू के साथ, ट्रेनिंग ऐप्लिकेशन के कई ट्रायल चलाकर काम करती है. ये वैल्यू, आपकी तय की गई सीमाओं के अंदर सेट होती हैं. Vertex AI, हर ट्रायल के नतीजों को ट्रैक करता है और अगले ट्रायल के लिए अडजस्टमेंट करता है.

Vertex AI की ट्रेनिंग के साथ हाइपर पैरामीटर ट्यूनिंग का इस्तेमाल करने के लिए, आपको अपने ट्रेनिंग कोड में दो बदलाव करने होंगे:

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

डिस्ट्रिब्यूटेड ट्रेनिंग

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

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

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

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

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

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

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

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

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

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

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

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

अपने Cloud Console के Vertex AI सेक्शन में, वर्कबेंच पर क्लिक करें:

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

इसके बाद, मैनेज की गई किताबें पर क्लिक करें:

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

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

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

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

अन्य सभी बेहतर सेटिंग को पहले जैसा ही रहने दें.

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

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

पहली बार किसी नए इंस्टेंस का इस्तेमाल करने पर, आपसे पुष्टि करने के लिए कहा जाएगा. ऐसा करने के लिए, यूज़र इंटरफ़ेस (यूआई) में दिया गया तरीका अपनाएं.

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

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

vertex-codelab नाम की एक नई डायरेक्ट्री बनाएं और उसमें cd करें.

mkdir vertex-codelab
cd vertex-codelab

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

mkdir trainer
touch trainer/task.py

अब आपको अपनी vertex-codelab डायरेक्ट्री में ये चीज़ें दिखनी चाहिए:

+ trainer/
    + task.py

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

import tensorflow as tf
import tensorflow_datasets as tfds
import argparse
import hypertune
import os

NUM_EPOCHS = 10
BATCH_SIZE = 64

def get_args():
  '''Parses args. Must include all hyperparameters you want to tune.'''

  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--learning_rate',
      required=True,
      type=float,
      help='learning rate')
  parser.add_argument(
      '--momentum',
      required=True,
      type=float,
      help='SGD momentum value')
  parser.add_argument(
      '--num_units',
      required=True,
      type=int,
      help='number of units in last hidden layer')
  args = parser.parse_args()
  return args


def preprocess_data(image, label):
  '''Resizes and scales images.'''

  image = tf.image.resize(image, (150,150))
  return tf.cast(image, tf.float32) / 255., label


def create_dataset(batch_size):
  '''Loads Horses Or Humans dataset and preprocesses data.'''

  data, info = tfds.load(name='horses_or_humans', as_supervised=True, with_info=True)

  # Create train dataset
  train_data = data['train'].map(preprocess_data)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)

  # Create validation dataset
  validation_data = data['test'].map(preprocess_data)
  validation_data  = validation_data.batch(batch_size)

  return train_data, validation_data


def create_model(num_units, learning_rate, momentum):
  '''Defines and compiles model.'''

  inputs = tf.keras.Input(shape=(150, 150, 3))
  x = tf.keras.layers.Conv2D(16, (3, 3), activation='relu')(inputs)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Flatten()(x)
  x = tf.keras.layers.Dense(num_units, activation='relu')(x)
  outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
  model = tf.keras.Model(inputs, outputs)
  model.compile(
      loss='binary_crossentropy',
      optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum),
      metrics=['accuracy'])
  return model


def main():
  args = get_args()

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

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, validation_data = create_dataset(GLOBAL_BATCH_SIZE)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(args.num_units, args.learning_rate, args.momentum)

  # Train model
  history = model.fit(train_data, epochs=NUM_EPOCHS, validation_data=validation_data)

  # Define metric
  hp_metric = history.history['val_accuracy'][-1]

  hpt = hypertune.HyperTune()
  hpt.report_hyperparameter_tuning_metric(
      hyperparameter_metric_tag='accuracy',
      metric_value=hp_metric,
      global_step=NUM_EPOCHS)


if __name__ == "__main__":
    main()

आइए, कोड को गहराई से समझते हैं और डिस्ट्रिब्यूटेड ट्रेनिंग और हाइपर पैरामीटर ट्यूनिंग के कॉम्पोनेंट के बारे में जानते हैं.

डिस्ट्रिब्यूटेड ट्रेनिंग

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

हाइपर पैरामीटर ट्यूनिंग

1. स्क्रिप्ट, hypertune लाइब्रेरी को इंपोर्ट करती है. बाद में, कंटेनर इमेज बनाते समय, हमें यह पक्का करना होगा कि हमने यह लाइब्रेरी इंस्टॉल कर ली है.
2. get_args() फ़ंक्शन, हर उस हाइपरपैरामीटर के लिए कमांड-लाइन आर्ग्युमेंट तय करता है जिसे आपको ट्यून करना है. इस उदाहरण में, ट्यून किए जाने वाले हाइपरपैरामीटर में लर्निंग रेट, ऑप्टिमाइज़र में मोमेंटम वैल्यू, और मॉडल की आखिरी हिडन लेयर में यूनिट की संख्या शामिल है. हालांकि, दूसरे हाइपरपैरामीटर के साथ भी प्रयोग किया जा सकता है. इसके बाद, उन आर्ग्युमेंट में दी गई वैल्यू का इस्तेमाल, कोड में उससे जुड़े हाइपरपैरामीटर को सेट करने के लिए किया जाता है (उदाहरण के लिए, learning_rate = args.learning_rate सेट करें)
3. main() फ़ंक्शन के आखिर में, hypertune लाइब्रेरी का इस्तेमाल उस मेट्रिक को तय करने के लिए किया जाता है जिसे आपको ऑप्टिमाइज़ करना है. TensorFlow में, Keras model.fit तरीका History ऑब्जेक्ट दिखाता है. History.history एट्रिब्यूट, ट्रेनिंग लॉस वैल्यू और मेट्रिक वैल्यू का रिकॉर्ड होता है. यह रिकॉर्ड, हर एपिसोड के लिए अलग-अलग होता है. अगर पुष्टि करने के लिए डेटा को model.fit एट्रिब्यूट में पास किया जाता है, तो History.history एट्रिब्यूट में पुष्टि न होने की वजह और मेट्रिक की वैल्यू भी शामिल होंगी. उदाहरण के लिए, अगर आपने पुष्टि करने वाले डेटा की मदद से तीन एपिसोड के लिए मॉडल को ट्रेन किया है और मेट्रिक के तौर पर accuracy दिया है, तो History.history एट्रिब्यूट, नीचे दी गई डिक्शनरी की तरह दिखेगा.

{
 "accuracy": [
   0.7795261740684509,
   0.9471358060836792,
   0.9870933294296265
 ],
 "loss": [
   0.6340447664260864,
   0.16712145507335663,
   0.04546636343002319
 ],
 "val_accuracy": [
   0.3795261740684509,
   0.4471358060836792,
   0.4870933294296265
 ],
 "val_loss": [
   2.044623374938965,
   4.100203514099121,
   3.0728273391723633
 ]

अगर आपको हाइपर पैरामीटर ट्यूनिंग सेवा की मदद से, ऐसी वैल्यू खोजने की सुविधा चाहिए जो मॉडल की पुष्टि को ज़्यादा सटीक बनाती हैं, तो आपको val_accuracy सूची की आखिरी एंट्री (या NUM_EPOCS - 1) के तौर पर मेट्रिक का इस्तेमाल करना होगा. इसके बाद, इस मेट्रिक को HyperTune के किसी इंस्टेंस में पास करें. hyperparameter_metric_tag के लिए, अपनी पसंद की कोई भी स्ट्रिंग चुनी जा सकती है. हालांकि, आपको बाद में, हाइपरपैरामीटर ट्यूनिंग जॉब शुरू करते समय, स्ट्रिंग का फिर से इस्तेमाल करना होगा.

6. कोड को कंटेनर में रखें

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

पहला चरण: Dockerfile लिखना

अपने टर्मिनल में, पक्का करें कि आप vertex-codelab डायरेक्ट्री में हों. इसके बाद, एक खाली Dockerfile बनाएं:

touch Dockerfile

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

+ Dockerfile
+ trainer/
    + task.py

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

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

WORKDIR /

# Installs hypertune library
RUN pip install cloudml-hypertune

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

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

दूसरा चरण: कंटेनर बनाना

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

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

PROJECT_ID='your-cloud-project'

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

IMAGE_URI="gcr.io/$PROJECT_ID/horse-human-codelab:latest"

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

gcloud auth configure-docker

इसके बाद, अपनी vertex-codelab डायरेक्ट्री के रूट से यह चलाकर कंटेनर बनाएं:

docker build ./ -t $IMAGE_URI

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

docker push $IMAGE_URI

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

ट्रेनिंग जॉब में, हम स्टेजिंग बकेट का पाथ पास करेंगे.

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

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

7. हाइपरपैरामीटर ट्यूनिंग जॉब लॉन्च करना

पहला चरण: हाइपरपैरामीटर ट्यूनिंग की मदद से कस्टम ट्रेनिंग जॉब बनाना

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

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

from google.cloud import aiplatform
from google.cloud.aiplatform import hyperparameter_tuning as hpt

हाइपर पैरामीटर ट्यूनिंग जॉब को लॉन्च करने के लिए, आपको पहले worker_pool_specs तय करना होगा. इससे मशीन टाइप और Docker इमेज की जानकारी मिलती है. नीचे दी गई स्पेसिफ़िकेशन में, दो NVIDIA Tesla V100 जीपीयू वाली एक मशीन के बारे में बताया गया है.

आपको 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 = [{
    "machine_spec": {
        "machine_type": "n1-standard-4",
        "accelerator_type": "NVIDIA_TESLA_V100",
        "accelerator_count": 2
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "gcr.io/{PROJECT_ID}/horse-human-codelab:latest"
    }
}]

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

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

# Dictionary representing parameters to optimize.
# The dictionary key is the parameter_id, which is passed into your training
# job as a command line argument,
# And the dictionary value is the parameter specification of the metric.
parameter_spec = {
    "learning_rate": hpt.DoubleParameterSpec(min=0.001, max=1, scale="log"),
    "momentum": hpt.DoubleParameterSpec(min=0, max=1, scale="linear"),
    "num_units": hpt.DiscreteParameterSpec(values=[64, 128, 512], scale=None)
}

आखिरी शर्त metric_spec है, जो ऑप्टिमाइज़ की जाने वाली मेट्रिक की जानकारी देने वाली डिक्शनरी है. डिक्शनरी कुंजी वह hyperparameter_metric_tag होती है जिसे आपने अपने ट्रेनिंग ऐप्लिकेशन कोड में सेट किया है और इसका मान ऑप्टिमाइज़ेशन लक्ष्य होता है.

# Dicionary representing metrics to optimize.
# The dictionary key is the metric_id, which is reported by your training job,
# And the dictionary value is the optimization goal of the metric.
metric_spec={'accuracy':'maximize'}

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

आपको {YOUR_BUCKET} को उस बकेट से बदलना होगा जिसे आपने पहले बनाया था.

# Replace YOUR_BUCKET
my_custom_job = aiplatform.CustomJob(display_name='horses-humans',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

इसके बाद, HyperparameterTuningJob बनाएं और चलाएं.

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='horses-humans',
    custom_job=my_custom_job,
    metric_spec=metric_spec,
    parameter_spec=parameter_spec,
    max_trial_count=6,
    parallel_trial_count=2,
    search_algorithm=None)

hp_job.run()

ध्यान देने वाली कुछ बातें:

• max_trial_count: आपको यह तय करना होगा कि सेवा कितनी बार ट्रायल के तौर पर उपलब्ध कराई जाएगी. आम तौर पर, ज़्यादा ट्रायल करने से बेहतर नतीजे मिलते हैं. हालांकि, एक समय के बाद नतीजों में फ़र्क़ नहीं पड़ता. इसके बाद, अतिरिक्त ट्रायल करने से उस मेट्रिक पर काफ़ी कम या कोई असर नहीं पड़ता जिसे ऑप्टिमाइज़ किया जा रहा है. सबसे सही तरीका यह है कि आप कम ट्रायल के साथ शुरुआत करें और स्केल अप करने से पहले, यह समझ लें कि आपके चुने गए हाइपरपैरामीटर कितने असरदार हैं.
• Parallel_trial_count: अगर पैरलल ट्रायल का इस्तेमाल किया जा रहा है, तो सेवा एक से ज़्यादा ट्रेनिंग प्रोसेसिंग क्लस्टर का प्रावधान करती है. एक साथ कई ट्रायल चलाने से, हाइपरपैरामीटर ट्यूनिंग जॉब को चलने में लगने वाला समय कम हो जाता है. हालांकि, इससे जॉब के असर में कमी आ सकती है. ऐसा इसलिए होता है, क्योंकि डिफ़ॉल्ट ट्यूनिंग की रणनीति, पिछले ट्रायल के नतीजों का इस्तेमाल करके, अगले ट्रायल में वैल्यू असाइन करने की जानकारी देती है.
• search_algorithm: खोज के लिए इस्तेमाल होने वाले एल्गोरिद्म को ग्रिड, रैंडम या डिफ़ॉल्ट (कोई नहीं) पर सेट किया जा सकता है. डिफ़ॉल्ट विकल्प, संभावित हाइपर पैरामीटर वैल्यू के स्पेस को खोजने के लिए बेज़ियन ऑप्टिमाइज़ेशन को लागू करता है. यह सुझाया गया एल्गोरिदम है. इस एल्गोरिदम के बारे में ज़्यादा जानने के लिए, यहां जाएं.

नौकरी शुरू होने के बाद, यूज़र इंटरफ़ेस (यूआई) में इसकी स्थिति को HYPERPARAMETER ट्यूनिंग जॉब टैब में ट्रैक किया जा सकता है.

जॉब पूरा होने के बाद, हाइपरपैरामीटर वैल्यू का सबसे अच्छा कॉम्बिनेशन ढूंढने के लिए, अपने ट्रायल के नतीजे देखे और क्रम से लगाए जा सकते हैं.

🎉 बधाई हो! 🎉

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

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

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

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

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

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