इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी
1. खास जानकारी
इस लैब में, TensorFlow के मॉडल के लिए हाइपर पैरामीटर ट्यूनिंग जॉब चलाने के लिए, Vertex AI का इस्तेमाल किया जाएगा. यह लैब, मॉडल कोड के लिए TensorFlow का इस्तेमाल करती है, लेकिन ये सिद्धांत अन्य एमएल फ़्रेमवर्क पर भी लागू होते हैं.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- अपने-आप हाइपर पैरामीटर ट्यूनिंग के लिए, ट्रेनिंग ऐप्लिकेशन कोड में बदलाव करें
- Vertex AI यूज़र इंटरफ़ेस (यूआई) की मदद से, हाइपर पैरामीटर ट्यूनिंग जॉब को कॉन्फ़िगर और लॉन्च करें
- Vertex AI Python SDK की मदद से, हाइपर पैरामीटर ट्यूनिंग जॉब को कॉन्फ़िगर और लॉन्च करना
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $3 USD है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपका कोई सुझाव, राय या शिकायत है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई तरह के प्रॉडक्ट शामिल हैं, जो मशीन लर्निंग के वर्कफ़्लो को मैनेज करने में मदद करते हैं. यह लैब, यहां हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस करेगी: ट्रेनिंग और वर्कबेंच.
3. अपना एनवायरमेंट सेट अप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: 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 खोलें को चुनें.
पहली बार किसी नए इंस्टेंस का इस्तेमाल करने पर, आपसे पुष्टि करने के लिए कहा जाएगा. ऐसा करने के लिए, यूज़र इंटरफ़ेस (यूआई) में दिया गया तरीका अपनाएं.
4. ट्रेनिंग ऐप्लिकेशन कोड को कंटेनर में बदलें
आपको इस लैब में जिस मॉडल की ट्रेनिंग और ट्यूनिंग करनी है वह इमेज क्लासिफ़िकेशन मॉडल है. इस मॉडल को TensorFlow डेटासेट से, घोड़ों या इंसानों के डेटासेट पर ट्रेनिंग दी गई है.
आपको Docker कंटेनर में अपने ट्रेनिंग ऐप्लिकेशन कोड को डालकर और इस कंटेनर को Google Container Registry में डालकर, Vertex AI को हाइपरपैरामीटर ट्यूनिंग की यह जॉब सबमिट करनी होगी. इस तरीके का इस्तेमाल करके, किसी भी फ़्रेमवर्क के साथ बनाए गए मॉडल के लिए, हाइपर पैरामीटर को ट्यून किया जा सकता है.
शुरू करने के लिए, लॉन्चर मेन्यू में जाकर, अपने notebook के इंस्टेंस में टर्मिनल विंडो खोलें:
horses_or_humans नाम की एक नई डायरेक्ट्री बनाएं और उसमें सीडी लें:
mkdir horses_or_humans
cd horses_or_humans
पहला चरण: Dockerfile बनाना
अपने कोड को कंटेनर बनाने के लिए सबसे पहले, Dockerfile बनाएं. Dockerfile में, आप इमेज को चलाने के लिए ज़रूरी सभी कमांड शामिल करेंगे. यह CloudML Hypertune लाइब्रेरी के साथ-साथ सभी ज़रूरी लाइब्रेरी इंस्टॉल करेगा. साथ ही, ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप करेगा.
अपने Terminal से, एक खाली Dockerfile बनाएं:
touch Dockerfile
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, डीप लर्निंग कंटेनर TensorFlow Enterprise 2.7 जीपीयू Docker इमेज का इस्तेमाल करता है. Google Cloud पर डीप लर्निंग कंटेनर में, एमएल और डेटा साइंस के कई सामान्य फ़्रेमवर्क पहले से इंस्टॉल होते हैं. उस इमेज को डाउनलोड करने के बाद, यह Dockerfile ट्रेनिंग कोड के लिए एंट्रीपॉइंट सेट अप करता है. आपने अभी तक ये फ़ाइलें नहीं बनाई हैं – अगले चरण में, आपको मॉडल की ट्रेनिंग और इसे ट्यून करने के लिए कोड जोड़ना होगा.
दूसरा चरण: मॉडल ट्रेनिंग कोड जोड़ना
अपने Terminal से, ट्रेनिंग कोड और Python फ़ाइल की डायरेक्ट्री बनाने के लिए इन कोड को चलाएं, जिनमें कोड जोड़ना है:
mkdir trainer
touch trainer/task.py
अब आपको अपनी horses_or_humans/ डायरेक्ट्री में ये चीज़ें दिखनी चाहिए:
+ Dockerfile
+ trainer/
+ task.py
इसके बाद, अभी-अभी बनाई गई task.py फ़ाइल खोलें और नीचे दिए गए कोड को कॉपी करें.
import tensorflow as tf
import tensorflow_datasets as tfds
import argparse
import hypertune
NUM_EPOCHS = 10
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():
'''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(64)
# Create validation dataset
validation_data = data['test'].map(preprocess_data)
validation_data = validation_data.batch(64)
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()
train_data, validation_data = create_dataset()
model = create_model(args.num_units, args.learning_rate, args.momentum)
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()
कंटेनर बनाने से पहले, आइए कोड को गहराई से समझें. हाइपर पैरामीटर ट्यूनिंग सेवा के इस्तेमाल के लिए कुछ कॉम्पोनेंट खास तौर पर उपलब्ध होते हैं.
- स्क्रिप्ट,
hypertuneलाइब्रेरी को इंपोर्ट करती है. ध्यान दें कि पहले चरण के Dockerfile में इस लाइब्रेरी को पीआईपी (पिक्चर में पिक्चर) इंस्टॉल करने के निर्देश शामिल हैं. get_args()फ़ंक्शन, हर उस हाइपरपैरामीटर के लिए कमांड-लाइन आर्ग्युमेंट तय करता है जिसे आपको ट्यून करना है. इस उदाहरण में, लर्निंग रेट, ऑप्टिमाइज़र में मोमेंटम वैल्यू, और मॉडल की आखिरी हिडन लेयर में यूनिट की संख्या जैसे हाइपरपैरामीटर को ट्यून किया जाएगा. हालांकि, दूसरे हाइपरपैरामीटर के साथ भी प्रयोग किया जा सकता है. इसके बाद, उन आर्ग्युमेंट में पास की गई वैल्यू का इस्तेमाल, कोड में उससे जुड़े हाइपर पैरामीटर को सेट करने के लिए किया जाता है.main()फ़ंक्शन के आखिर में,hypertuneलाइब्रेरी का इस्तेमाल उस मेट्रिक को तय करने के लिए किया जाता है जिसे आपको ऑप्टिमाइज़ करना है. TensorFlow में, kerasmodel.fitतरीका एकHistoryऑब्जेक्ट दिखाता है.History.historyएट्रिब्यूट, एक के बाद एक चलने वाले epoch का इस्तेमाल करके, ट्रेनिंग में हुई कमी की वैल्यू और मेट्रिक की वैल्यू का रिकॉर्ड है. अगर आपने पुष्टि करने के लिए डेटा को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 के लिए अपनी पसंद की कोई भी स्ट्रिंग चुनी जा सकती है. हालांकि, हाइपर पैरामीटर ट्यूनिंग जॉब को बंद करने पर, आपको इस स्ट्रिंग का फिर से इस्तेमाल करना होगा.
तीसरा चरण: कंटेनर बनाना
अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, अपने Terminal से, इसे चलाएं और your-cloud-project को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:
PROJECT_ID='your-cloud-project'
Google Container Registry में, अपनी कंटेनर इमेज के यूआरआई के साथ वैरिएबल तय करें:
IMAGE_URI="gcr.io/$PROJECT_ID/horse-human:hypertune"
डॉकर कॉन्फ़िगर करें
gcloud auth configure-docker
इसके बाद, अपनी horses_or_humans डायरेक्ट्री के रूट से नीचे दिए गए निर्देशों को चलाकर कंटेनर बनाएं:
docker build ./ -t $IMAGE_URI
आखिर में, इसे Google कंटेनर रजिस्ट्री में भेजें:
docker push $IMAGE_URI
कंटेनर को Container Registry में पुश किए जाने के बाद, अब आप कस्टम मॉडल हाइपर पैरामीटर ट्यूनिंग का काम शुरू करने के लिए तैयार हैं.
5. Vertex AI में हाइपर पैरामीटर ट्यूनिंग जॉब चलाएं
यह लैब, Google Container Registry पर कस्टम कंटेनर की मदद से कस्टम ट्रेनिंग का इस्तेमाल करता है. हालांकि, Vertex AI के पहले से बने कंटेनर की मदद से भी, हाइपरपैरामीटर ट्यूनिंग जॉब चलाया जा सकता है.
शुरू करने के लिए, अपने Cloud Console के Vertex सेक्शन में ट्रेनिंग सेक्शन पर जाएं:
पहला चरण: ट्रेनिंग जॉब कॉन्फ़िगर करना
हाइपर पैरामीटर ट्यूनिंग जॉब के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें.
- डेटासेट में जाकर, कोई मैनेज किया गया डेटासेट नहीं है चुनें
- इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (ऐडवांस) चुनें और जारी रखें पर क्लिक करें.
- मॉडल का नाम के लिए
horses-humans-hyptertune(या जिसे भी आप अपने मॉडल को पुकारना चाहते हैं) डालें - जारी रखें पर क्लिक करें
कंटेनर सेटिंग चरण में, कस्टम कंटेनर चुनें:
पहले बॉक्स (कंटेनर इमेज) में, पिछले सेक्शन से अपने IMAGE_URI वैरिएबल की वैल्यू डालें. यह इस तरह होना चाहिए: gcr.io/your-cloud-project/horse-human:hypertune, जिसमें आपके प्रोजेक्ट का नाम हो. बाकी फ़ील्ड को खाली छोड़ दें और जारी रखें पर क्लिक करें.
दूसरा चरण: हाइपर पैरामीटर ट्यूनिंग जॉब को कॉन्फ़िगर करना
हाइपर पैरामीटर ट्यूनिंग चालू करें चुनें.
हाइपर पैरामीटर कॉन्फ़िगर करना
इसके बाद, आपको ट्रेनिंग ऐप्लिकेशन कोड में, कमांड लाइन आर्ग्युमेंट के तौर पर सेट किए गए हाइपरपैरामीटर जोड़ने होंगे. हाइपर पैरामीटर जोड़ते समय, आपको पहले नाम देना होगा. यह नाम, argparse को दिए गए आर्ग्युमेंट के नाम से मेल खाना चाहिए.
इसके बाद, ट्यूनिंग सेवा के लिए टाइप चुनने के साथ-साथ, उन वैल्यू की सीमाओं को भी चुना जा सकता है. अगर आपने टाइप डबल या पूर्णांक चुना है, तो आपको कम से कम और ज़्यादा से ज़्यादा वैल्यू देनी होगी. अगर आपने 'कैटगरी' या 'अलग-अलग' विकल्प चुना है, तो आपको वैल्यू भी देनी होगी.
डबल और पूर्णांक टाइप के लिए, आपको स्केलिंग वैल्यू भी देनी होगी.
learning_rate हाइपर पैरामीटर जोड़ने के बाद, momentum और num_units के लिए पैरामीटर जोड़ें.
मेट्रिक कॉन्फ़िगर करें
हाइपरपैरामीटर जोड़ने के बाद, आपको वह मेट्रिक और लक्ष्य देना होगा जिसे ऑप्टिमाइज़ करना है. यह वही hyperparameter_metric_tag होना चाहिए जिसे आपने ट्रेनिंग ऐप्लिकेशन में सेट किया है.
Vertex AI हाइपर पैरामीटर ट्यूनिंग सेवा, पिछले चरणों में कॉन्फ़िगर की गई वैल्यू के हिसाब से आपके ट्रेनिंग ऐप्लिकेशन को कई टेस्ट चलाएगी. सेवा के लिए चलाए जाने वाले ट्रायल की संख्या के लिए, आपको ऊपरी सीमा तय करनी होगी. आम तौर पर, ज़्यादा ट्रायल करने से बेहतर नतीजे मिलते हैं. हालांकि, एक समय के बाद ट्रायल का फ़ायदा कम हो जाता है. इसके बाद, अतिरिक्त ट्रायल से उस मेट्रिक पर काफ़ी कम या कोई असर नहीं पड़ता जिसे ऑप्टिमाइज़ करने की कोशिश की जा रही है. सबसे सही तरीका यह है कि कम ट्रायल से शुरुआत करें. साथ ही, ज़्यादा ट्रायल करने से पहले, यह पता लगाएं कि आपके चुने गए हाइपरपैरामीटर कितने असरदार हैं.
आपको समानांतर ट्रायल की संख्या के लिए भी ऊपरी सीमा सेट करनी होगी. एक साथ चलने वाले ट्रायल की संख्या बढ़ाने से, हाइपरपैरामीटर ट्यूनिंग जॉब को चलने में लगने वाला समय कम हो जाएगा. हालांकि, इससे जॉब की परफ़ॉर्मेंस पर असर पड़ सकता है. ऐसा इसलिए होता है, क्योंकि डिफ़ॉल्ट ट्यूनिंग की रणनीति, पिछले ट्रायल के नतीजों का इस्तेमाल करके, अगले ट्रायल में वैल्यू असाइन करने की जानकारी देती है. अगर एक साथ कई ट्रायल चलाए जाते हैं, तो ऐसे ट्रायल शुरू हो जाएंगे जो चल रहे ट्रायल के नतीजों का फ़ायदा लिए बिना शुरू होंगे.
उदाहरण के लिए, ट्रायल की संख्या 15 और पैरलल ट्रायल की ज़्यादा से ज़्यादा संख्या 3 पर सेट की जा सकती है. अलग-अलग नंबर के साथ एक्सपेरिमेंट किया जा सकता है. हालांकि, इससे ट्यूनिंग का समय बढ़ सकता है और लागत भी बढ़ सकती है.
आखिरी चरण खोज एल्गोरिदम के रूप में डिफ़ॉल्ट को चुनना है, जो हाइपर पैरामीटर ट्यूनिंग के लिए बेज़ियन ऑप्टिमाइज़ेशन करने के लिए Google Vizier का इस्तेमाल करेगा. इस एल्गोरिदम के बारे में यहां ज़्यादा जानें.
जारी रखें पर क्लिक करें.
तीसरा चरण: कंप्यूट को कॉन्फ़िगर करें
कंप्यूट और कीमत में, चुने गए क्षेत्र को वैसे ही रहने दें और Worker Pool 0 को नीचे बताए गए तरीके से कॉन्फ़िगर करें.
हाइपर पैरामीटर ट्यूनिंग जॉब को शुरू करने के लिए, ट्रेनिंग शुरू करें पर क्लिक करें. HYPERPARAMETER TUNING विज्ञापनों टैब के तहत, अपने कंसोल के ट्रेनिंग सेक्शन में आपको कुछ ऐसा दिखेगा:
जब यह खत्म हो जाएगा, तो आप जॉब के नाम पर क्लिक कर सकेंगे और ट्यूनिंग के ट्रायल के नतीजे देख सकेंगे.
🎉 बधाई हो! 🎉
आपने Vertex AI को इस्तेमाल करने का तरीका सीख लिया है, ताकि:
- कस्टम कंटेनर में दिए गए ट्रेनिंग कोड के लिए, हाइपर पैरामीटर ट्यूनिंग जॉब लॉन्च करें. आपने इस उदाहरण में TensorFlow मॉडल का इस्तेमाल किया है, लेकिन आपके पास कस्टम कंटेनर का इस्तेमाल करके किसी भी फ़्रेमवर्क के साथ बनाए गए मॉडल को ट्रेनिंग देने का विकल्प है.
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
6. [ज़रूरी नहीं] Vertex SDK टूल का इस्तेमाल करना
पिछले सेक्शन में, यूज़र इंटरफ़ेस (यूआई) की मदद से, हाइपरपैरामीटर ट्यूनिंग जॉब को लॉन्च करने का तरीका बताया गया था. इस सेक्शन में, Vertex Python API का इस्तेमाल करके, हाइपर पैरामीटर ट्यूनिंग जॉब सबमिट करने का दूसरा तरीका बताया गया है.
लॉन्चर से, TensorFlow 2 नोटबुक बनाएं.
Vertex AI SDK टूल इंपोर्ट करें.
from google.cloud import aiplatform
from google.cloud.aiplatform import hyperparameter_tuning as hpt
हाइपर पैरामीटर ट्यूनिंग जॉब को लॉन्च करने के लिए, आपको पहले नीचे दी गई जानकारी देनी होगी. आपको अपने प्रोजेक्ट के 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": 1
},
"replica_count": 1,
"container_spec": {
"image_uri": "gcr.io/{PROJECT_ID}/horse-human:hypertune"
}
}]
# Dictionary 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'}
# 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)
}
इसके बाद, CustomJob बनाएं. स्टेजिंग के लिए, आपको अपने प्रोजेक्ट में {YOUR_BUCKET} को बकेट से बदलना होगा.
# Replace YOUR_BUCKET
my_custom_job = aiplatform.CustomJob(display_name='horses-humans-sdk-job',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
इसके बाद, HyperparameterTuningJob बनाएं और चलाएं.
hp_job = aiplatform.HyperparameterTuningJob(
display_name='horses-humans-sdk-job',
custom_job=my_custom_job,
metric_spec=metric_spec,
parameter_spec=parameter_spec,
max_trial_count=15,
parallel_trial_count=3)
hp_job.run()
7. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक कोई गतिविधि न होने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने के बारे में चिंता करने की ज़रूरत नहीं है. अगर आपको मैन्युअल तरीके से इंस्टेंस शट डाउन करना है, तो कंसोल के Vertex AI Workbench सेक्शन में, 'रोकें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
