1. खास जानकारी
इस लैब में, आपको TensorFlow के मॉडल के लिए, मल्टी-वर्कर ट्रेनिंग जॉब चलाने के लिए Vertex AI का इस्तेमाल करना होगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- एक से ज़्यादा वर्कर्स को ट्रेनिंग देने के लिए, ट्रेनिंग ऐप्लिकेशन कोड में बदलाव करना
- Vertex AI के यूज़र इंटरफ़ेस (यूआई) से, एक से ज़्यादा वर्कर्स वाली ट्रेनिंग जॉब को कॉन्फ़िगर और लॉन्च करना
- Vertex SDK टूल की मदद से, एक से ज़्यादा वर्कर्स के लिए ट्रेनिंग जॉब कॉन्फ़िगर करना और उसे लॉन्च करना
Google Cloud पर इस लैब को चलाने की कुल लागत 5 डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करता है. Vertex AI, Google Cloud के सभी एमएल ऑफ़र को डेवलपमेंट के बेहतर अनुभव के साथ इंटिग्रेट करता है. पहले, AutoML की मदद से ट्रेन किए गए मॉडल और कस्टम मॉडल को अलग-अलग सेवाओं से ऐक्सेस किया जा सकता था. नई सुविधा में, दोनों को एक ही एपीआई में जोड़ा गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपका कोई सुझाव, शिकायत या राय है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि एंड-टू-एंड एमएल वर्कफ़्लो को बेहतर बनाया जा सके. इस लैब में, नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: ट्रेनिंग और वर्कबेंच
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, TensorFlow Datasets से cassava डेटासेट पर इमेज क्लासिफ़िकेशन मॉडल को ट्रेनिंग देने के लिए, ट्रांसफ़र लर्निंग का इस्तेमाल किया जाएगा. इस प्रयोग में, tf.keras.applications लाइब्रेरी से ResNet50 मॉडल का इस्तेमाल किया जाएगा. यह मॉडल, Imagenet डेटासेट पर पहले से ट्रेन किया गया है.
डिस्ट्रिब्यूटेड ट्रेनिंग क्यों?
अगर आपके पास एक जीपीयू है, तो TensorFlow इस एक्सेलेरेटर का इस्तेमाल करके मॉडल को तेज़ी से ट्रेन करेगा. इसके लिए, आपको कुछ भी करने की ज़रूरत नहीं है. हालांकि, अगर आपको एक ही मशीन या एक से ज़्यादा मशीनों (हर मशीन में कई जीपीयू) पर कई जीपीयू का इस्तेमाल करके, बेहतर परफ़ॉर्मेंस चाहिए, तो आपको tf.distribute का इस्तेमाल करना होगा. यह TensorFlow की लाइब्रेरी है, जिसका इस्तेमाल करके एक से ज़्यादा डिवाइसों पर कैलकुलेशन की जा सकती है. डिवाइस का मतलब किसी मशीन पर मौजूद सीपीयू या ऐक्सेलरेटर से है. जैसे, जीपीयू या टीपीयू. TensorFlow, इन पर ऑपरेशन चला सकता है.
डिस्ट्रिब्यूटेड ट्रेनिंग की शुरुआत करने का सबसे आसान तरीका, एक ऐसी मशीन है जिसमें कई जीपीयू डिवाइस हों. tf.distribute मॉड्यूल की TensorFlow डिस्ट्रिब्यूशन की रणनीति, सभी जीपीयू में डेटा डिस्ट्रिब्यूशन और ग्रेडिएंट अपडेट के कोऑर्डिनेशन को मैनेज करेगी. अगर आपने सिंगल होस्ट ट्रेनिंग में महारत हासिल कर ली है और आपको और भी ज़्यादा स्केल करना है, तो अपने क्लस्टर में कई मशीनें जोड़ें. इससे आपको परफ़ॉर्मेंस में और भी ज़्यादा बढ़ोतरी देखने को मिल सकती है. ऐसी मशीनों के क्लस्टर का इस्तेमाल किया जा सकता है जो सिर्फ़ सीपीयू की सुविधा देते हैं या हर एक में एक या एक से ज़्यादा जीपीयू होते हैं. इस लैब में, बाद के मामले को कवर किया गया है. साथ ही, यह बताया गया है कि Vertex AI की मदद से, कई मशीनों पर TensorFlow मॉडल की ट्रेनिंग देने के लिए, MultiWorkerMirroredStrategy का इस्तेमाल कैसे किया जाए.
MultiWorkerMirroredStrategy, सिंक किए गए डेटा के लिए पैरलल प्रोसेसिंग की एक रणनीति है. इसका इस्तेमाल, कोड में कुछ बदलाव करके किया जा सकता है. आपके क्लस्टर के हर डिवाइस पर, मॉडल की एक कॉपी बनाई जाती है. बाद के ग्रेडिएंट अपडेट सिंक्रोनस तरीके से होंगे. इसका मतलब है कि हर वर्क डिवाइस, इनपुट डेटा के अलग-अलग स्लाइस पर मॉडल के फ़ॉरवर्ड और बैकवर्ड पास का हिसाब लगाता है. इसके बाद, इनमें से हर स्लाइस के लिए कैलकुलेट किए गए ग्रेडिएंट को मशीन और क्लस्टर के सभी डिवाइसों पर एग्रीगेट किया जाता है. साथ ही, 'सभी को कम करना' नाम की प्रोसेस में, आम तौर पर औसत निकाला जाता है. इसके बाद, ऑप्टिमाइज़र इन कम किए गए ग्रेडिएंट की मदद से पैरामीटर अपडेट करता है. इससे डिवाइसों को सिंक किया जा सकता है. TensorFlow की मदद से डिस्ट्रिब्यूटेड ट्रेनिंग के बारे में ज़्यादा जानने के लिए, यह वीडियो देखें:
4. अपना एनवायरमेंट सेट अप करें
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला 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 खोलें को चुनें.
किसी नए इंस्टेंस का पहली बार इस्तेमाल करने पर, आपसे पुष्टि करने के लिए कहा जाएगा. ऐसा करने के लिए, यूज़र इंटरफ़ेस (यूआई) में दिया गया तरीका अपनाएं.
5. ट्रेनिंग ऐप्लिकेशन कोड को कंटेनर में डालना
आपको इस ट्रेनिंग जॉब को Vertex में सबमिट करने के लिए, Docker कंटेनर में अपना ट्रेनिंग ऐप्लिकेशन कोड डालना होगा. इसके बाद, इस कंटेनर को Google Container Registry में भेजना होगा. इस तरीके का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.
शुरू करने के लिए, अपने नोटबुक इंस्टेंस में, लॉन्चर मेन्यू से Terminal विंडो खोलें:
cassava नाम की एक नई डायरेक्ट्री बनाएं और उसमें cd करें:
mkdir cassava
cd cassava
पहला चरण: Dockerfile बनाना
अपने कोड को कंटेनर में डालने के लिए, सबसे पहले Dockerfile बनाएं. Dockerfile में, आपको इमेज को चलाने के लिए ज़रूरी सभी निर्देश शामिल करने होंगे. इससे सभी ज़रूरी लाइब्रेरी इंस्टॉल हो जाएंगी और ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप हो जाएगा.
अपने Terminal से, एक खाली Dockerfile बनाएं:
touch Dockerfile
Dockerfile खोलें और इसमें यह कॉपी करें:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-7
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"]
यह Dockerfile, डीप लर्निंग कंटेनर TensorFlow Enterprise 2.7 जीपीयू Docker इमेज का इस्तेमाल करता है. Google Cloud पर डीप लर्निंग कंटेनर में, एमएल और डेटा साइंस के कई सामान्य फ़्रेमवर्क पहले से इंस्टॉल होते हैं. उस इमेज को डाउनलोड करने के बाद, यह Dockerfile ट्रेनिंग कोड के लिए एंट्रीपॉइंट सेट अप करता है. आपने अभी तक ये फ़ाइलें नहीं बनाई हैं – अगले चरण में, आपको मॉडल को ट्रेनिंग देने और ट्यून करने के लिए कोड जोड़ना होगा.
दूसरा चरण: Cloud Storage बकेट बनाना
इस ट्रेनिंग जॉब में, आपको ट्रेन किए गए TensorFlow मॉडल को Cloud Storage बकेट में एक्सपोर्ट करना होगा. अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, अपने टर्मिनल में यह तरीका अपनाएं. your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डालना न भूलें:
PROJECT_ID='your-cloud-project'
इसके बाद, अपने प्रोजेक्ट में नई बकेट बनाने के लिए, अपने टर्मिनल में यह कोड चलाएं.
BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET
तीसरा चरण: मॉडल ट्रेनिंग कोड जोड़ना
ट्रेनिंग कोड और Python फ़ाइल के लिए डायरेक्ट्री बनाने के लिए, अपने टर्मिनल में यह कोड चलाएं. इस फ़ाइल में आपको कोड जोड़ना होगा:
mkdir trainer
touch trainer/task.py
अब आपकी cassava/ डायरेक्ट्री में यह जानकारी होनी चाहिए:
+ Dockerfile
+ trainer/
+ task.py
इसके बाद, अभी-अभी बनाई गई task.py फ़ाइल खोलें और नीचे दिए गए कोड को कॉपी करें. आपको {your-gcs-bucket} की जगह, उस Cloud Storage बकेट का नाम डालना होगा जिसे आपने अभी बनाया है.
import tensorflow as tf
import tensorflow_datasets as tfds
import os
PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2
# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'
def preprocess_data(image, label):
'''Resizes and scales images.'''
image = tf.image.resize(image, (300,300))
return tf.cast(image, tf.float32) / 255., label
def create_dataset(batch_size):
'''Loads Cassava dataset and preprocesses data.'''
data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
number_of_classes = info.features['label'].num_classes
train_data = data['train'].map(preprocess_data,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
train_data = train_data.shuffle(1000)
train_data = train_data.batch(batch_size)
train_data = train_data.prefetch(tf.data.experimental.AUTOTUNE)
# Set AutoShardPolicy
options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
train_data = train_data.with_options(options)
return train_data, number_of_classes
def create_model(number_of_classes):
'''Creates and compiles pretrained ResNet50 model.'''
base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
x = base_model.output
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(1016, activation='relu')(x)
predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
model = tf.keras.Model(inputs=base_model.input, outputs=predictions)
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=tf.keras.optimizers.Adam(0.0001),
metrics=['accuracy'])
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 strategy
strategy = tf.distribute.MultiWorkerMirroredStrategy()
# Get data
global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
train_data, number_of_classes = create_dataset(global_batch_size)
# Wrap variable creation within strategy scope
with strategy.scope():
model = create_model(number_of_classes)
model.fit(train_data, 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(BUCKET, task_type, task_id)
model.save(write_model_path)
if __name__ == "__main__":
main()
कंटेनर बनाने से पहले, आइए कोड पर गौर करते हैं. यह कोड, tf.distribute.Strategy एपीआई के MultiWorkerMirroredStrategy का इस्तेमाल करता है.
कोड में कुछ ऐसे कॉम्पोनेंट होते हैं जो MultiWorkerMirroredStrategy के साथ आपके कोड के काम करने के लिए ज़रूरी होते हैं.
- डेटा को अलग-अलग हिस्सों में बांटना होगा. इसका मतलब है कि हर वर्कर्स को पूरे डेटासेट का एक सबसेट असाइन किया जाएगा. इसलिए, हर चरण में हर वर्कर, ओवरलैप न होने वाले डेटासेट एलिमेंट का ग्लोबल बैच साइज़ प्रोसेस करेगा. यह शर्डिंग
tf.data.experimental.AutoShardPolicyके साथ अपने-आप होती है. इसेFILEयाDATAपर सेट किया जा सकता है. इस उदाहरण में,create_dataset()फ़ंक्शनAutoShardPolicyकोDATAपर सेट करता है, क्योंकि cassava डेटासेट को एक से ज़्यादा फ़ाइलों के तौर पर डाउनलोड नहीं किया गया है. हालांकि, अगर आपने नीति कोDATAपर सेट नहीं किया है, तो डिफ़ॉल्टAUTOनीति लागू हो जाएगी और नतीजा वही होगा.MultiWorkerMirroredStrategyकी मदद से डेटासेट को अलग-अलग हिस्सों में बांटने के बारे में ज़्यादा जानने के लिए यहां जाएं. main()फ़ंक्शन में,MultiWorkerMirroredStrategyऑब्जेक्ट बनाया जाता है. इसके बाद, आपको रणनीति के स्कोप में मॉडल वैरिएबल बनाने की प्रोसेस पूरी करनी होगी. इस अहम चरण से TensorFlow का पता चलता है कि सभी प्रतियों में कौनसे वैरिएबल डुप्लीकेट होने चाहिए.- बैच का साइज़,
num_replicas_in_syncके हिसाब से बढ़ाया जाता है. इससे यह पक्का होता है कि हर चरण में हर एक प्रतिकृति, उदाहरणों की एक जैसी संख्या प्रोसेस करती है. TensorFlow में सिंक्रोनस डेटा पैरलेलिज्म की रणनीतियों का इस्तेमाल करते समय, बैच साइज़ को बढ़ाना सबसे सही तरीका है. - एक से ज़्यादा वर्कर्स के मामले में, मॉडल को सेव करना थोड़ा मुश्किल होता है. इसकी वजह यह है कि हर वर्कर्स के लिए डेस्टिनेशन अलग-अलग होना चाहिए. मुख्य वर्कर, मॉडल को अपनी पसंद की डायरेक्ट्री में सेव करेगा. वहीं, दूसरे वर्कर्स मॉडल को अस्थायी डायरेक्ट्री में सेव करेंगे. यह ज़रूरी है कि ये अस्थायी डायरेक्ट्री यूनीक हों, ताकि एक से ज़्यादा वर्कर्स एक ही जगह पर डेटा न डाल सकें. सेव करने की प्रोसेस में, सभी कर्मचारी शामिल हो सकते हैं. इसका मतलब है कि सिर्फ़ चीफ़ को सेव करने की ज़रूरत नहीं है.
_is_chief(),_get_temp_dir(),write_filepath(), औरmain()फ़ंक्शन में, मॉडल को सेव करने में मदद करने वाला बॉयलरप्लेट कोड शामिल होता है.
ध्यान दें कि अगर आपने MultiWorkerMirroredStrategy का इस्तेमाल किसी दूसरे एनवायरमेंट में किया है, तो हो सकता है कि आपने TF_CONFIG एनवायरमेंट वैरिएबल सेट अप किया हो. Vertex AI आपके लिए TF_CONFIG को अपने-आप सेट कर देता है. इसलिए, आपको अपने क्लस्टर की हर मशीन पर, इस वैरिएबल को तय करने की ज़रूरत नहीं है.
चौथा चरण: कंटेनर बनाना
अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, अपने टर्मिनल में यह तरीका अपनाएं. your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डालना न भूलें:
PROJECT_ID='your-cloud-project'
Google Container Registry में, अपनी कंटेनर इमेज के यूआरआई के साथ एक वैरिएबल तय करें:
IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"
Docker कॉन्फ़िगर करना
gcloud auth configure-docker
इसके बाद, अपनी cassava डायरेक्ट्री के रूट से यह चलाकर कंटेनर बनाएं:
docker build ./ -t $IMAGE_URI
आखिर में, इसे Google कंटेनर रजिस्ट्री में भेजें:
docker push $IMAGE_URI
कंटेनर रजिस्ट्री में भेजे गए कंटेनर के साथ, अब आप ट्रेनिंग का काम शुरू करने के लिए तैयार हैं.
6. Vertex AI में मल्टीवर्कर ट्रेनिंग का काम करें
यह लैब, Google Container Registry पर मौजूद कस्टम कंटेनर के ज़रिए कस्टम ट्रेनिंग का इस्तेमाल करती है. हालांकि, पहले से बने कंटेनर की मदद से भी ट्रेनिंग दी जा सकती है.
शुरू करने के लिए, अपने Cloud Console के Vertex सेक्शन में ट्रेनिंग सेक्शन पर जाएं:
पहला चरण: ट्रेनिंग जॉब कॉन्फ़िगर करना
अपने ट्रेनिंग जॉब के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें.
- डेटासेट में जाकर, मैनेज किया जा रहा कोई डेटासेट नहीं है चुनें
- इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (बेहतर) चुनें और जारी रखें पर क्लिक करें.
- मॉडल का नाम के लिए
multiworker-cassava(या जिसे भी आप अपने मॉडल को पुकारना चाहते हैं) डालें - जारी रखें पर क्लिक करें
कंटेनर की सेटिंग वाले चरण में, कस्टम कंटेनर चुनें:
पहले बॉक्स (कंटेनर इमेज) में, पिछले सेक्शन से अपने IMAGE_URI वैरिएबल की वैल्यू डालें. यह इस तरह होना चाहिए: gcr.io/your-cloud-project/multiworker:cassava, जिसमें आपका प्रोजेक्ट आईडी हो. बाकी फ़ील्ड खाली छोड़ें और जारी रखें पर क्लिक करें.
जारी रखें पर फिर से क्लिक करके, एच-हाइपरपैरामीटर का चरण छोड़ें.
दूसरा चरण: Compute क्लस्टर कॉन्फ़िगर करना
Vertex AI, मशीन से जुड़े अलग-अलग तरह के टास्क को पूरा करने के लिए, चार वर्कर्स पूल उपलब्ध कराता है.
वर्कर्स पूल 0, प्राइमरी, चीफ़, शेड्यूलर या "मास्टर" को कॉन्फ़िगर करता है. MultiWorkerMirroredStrategy में, सभी मशीनों को वर्कर्स के तौर पर दिखाया जाता है. ये वे फ़िज़िकल मशीनें होती हैं जिन पर डुप्लीकेट कैलकुलेशन किया जाता है. हर मशीन एक वर्कर्स है. इसके अलावा, एक वर्कर्स ऐसा होना चाहिए जो कुछ अतिरिक्त काम करता हो. जैसे, चेकपॉइंट सेव करना और TensorBoard में खास जानकारी वाली फ़ाइलें लिखना. इस मशीन को चीफ़ कहा जाता है. हमेशा एक ही चीफ़ वर्कर्स होता है. इसलिए, वर्कर्स पूल 0 के लिए वर्कर्स की संख्या हमेशा एक ही रहेगी.
कंप्यूट और कीमत में, चुने गए क्षेत्र को वैसे ही रहने दें और Worker Pool 0 को इस तरह कॉन्फ़िगर करें:
वर्कर पूल 1 में, अपने क्लस्टर के लिए वर्कर को कॉन्फ़िगर किया जाता है.
वर्कर पूल 1 को इस तरह से कॉन्फ़िगर करें:
क्लस्टर को अब सिर्फ़ दो सीपीयू मशीनों के लिए कॉन्फ़िगर किया गया है. ट्रेनिंग ऐप्लिकेशन कोड चलने पर, MultiWorkerMirroredStrategy दोनों मशीनों पर ट्रेनिंग देगा.
MultiWorkerMirroredStrategy में सिर्फ़ मुख्य और कर्मचारी वाले टास्क टाइप होते हैं. इसलिए, अतिरिक्त वर्कर पूल को कॉन्फ़िगर करने की ज़रूरत नहीं होती. हालांकि, अगर TensorFlow के ParameterServerStrategy का इस्तेमाल किया जाता, तो आपको वर्कर पूल 2 में अपने पैरामीटर सर्वर कॉन्फ़िगर करने होते. अगर आपको अपने क्लस्टर में कोई एवैल्यूएटर जोड़ना है, तो आपको उस मशीन को वर्कर्स पूल 3 में कॉन्फ़िगर करना होगा.
हाइपर पैरामीटर ट्यूनिंग जॉब को शुरू करने के लिए, ट्रेनिंग शुरू करें पर क्लिक करें. अपने कंसोल के ट्रेनिंग सेक्शन में, ट्रेनिंग पाइपलाइन टैब में आपको हाल ही में लॉन्च की गई नौकरी दिखेगी:
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके, ये काम करने का तरीका जाना है:
- कस्टम कंटेनर में दिए गए ट्रेनिंग कोड के लिए, कई वर्कर्स वाली ट्रेनिंग जॉब लॉन्च करें. इस उदाहरण में, TensorFlow मॉडल का इस्तेमाल किया गया है. हालांकि, कस्टम या पहले से मौजूद कंटेनर का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
7. [ज़रूरी नहीं] Vertex SDK टूल का इस्तेमाल करना
पिछले सेक्शन में, यूज़र इंटरफ़ेस (यूआई) के ज़रिए ट्रेनिंग जॉब को लॉन्च करने का तरीका दिखाया गया था. इस सेक्शन में, आपको Vertex Python API का इस्तेमाल करके, ट्रेनिंग जॉब सबमिट करने का एक और तरीका दिखेगा.
अपने नोटबुक इंस्टेंस पर वापस जाएं और लॉन्चर से TensorFlow 2 नोटबुक बनाएं:
Vertex AI SDK टूल इंपोर्ट करें.
from google.cloud import aiplatform
मल्टी-वर्कर ट्रेनिंग जॉब को लॉन्च करने के लिए, आपको सबसे पहले वर्कर पूल की खास बातें तय करनी होंगी. ध्यान दें कि खास जानकारी में जीपीयू का इस्तेमाल करना ज़रूरी नहीं है. अगर आपको पिछले सेक्शन में दिखाए गए तरीके से, सिर्फ़ सीपीयू वाले क्लस्टर चाहिए, तो accelerator_type और accelerator_count को हटाएं.
# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
},
"container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
},
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
},
"container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
}
]
इसके बाद, CustomJob बनाएं और चलाएं. स्टेजिंग के लिए, आपको अपने प्रोजेक्ट में {YOUR_BUCKET} को किसी बकेट से बदलना होगा. आप उसी बकेट का इस्तेमाल कर सकते हैं जिसे आपने पहले बनाया था.
# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
my_multiworker_job.run()
पसंद के मुताबिक बनाई गई नौकरियां टैब में, आपके कंसोल के ट्रेनिंग सेक्शन में आपको अपनी ट्रेनिंग की नौकरी दिखेगी:
8. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक इस्तेमाल में न होने पर, टाइम आउट होने के लिए कॉन्फ़िगर किया था. इसलिए, हमें इंस्टेंस बंद होने की चिंता करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, 'बंद करें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें:
