1. खास जानकारी
इस लैब में, Vertex AI का इस्तेमाल करके, TensorFlow मॉडल के लिए एक से ज़्यादा वर्कर वाला ट्रेनिंग जॉब चलाया जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- एक से ज़्यादा वर्कर की मदद से ट्रेनिंग देने के लिए, ट्रेनिंग ऐप्लिकेशन कोड में बदलाव करना
- Vertex AI के यूज़र इंटरफ़ेस (यूआई) से, एक से ज़्यादा वर्कर वाले ट्रेनिंग जॉब को कॉन्फ़िगर करना और लॉन्च करना
- Vertex SDK की मदद से, एक से ज़्यादा वर्कर वाले ट्रेनिंग जॉब को कॉन्फ़िगर करना और लॉन्च करना
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 500 रुपये है.
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है. अगर आपको कोई सुझाव देना है या शिकायत करनी है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: ट्रेनिंग और वर्कबेंच
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, TensorFlow Datasets से कसावा डेटासेट पर इमेज क्लासिफ़िकेशन मॉडल को ट्रेनिंग देने के लिए, ट्रांसफ़र लर्निंग का इस्तेमाल किया जाएगा. आपको जिस आर्किटेक्चर का इस्तेमाल करना है वह tf.keras.applications लाइब्रेरी का ResNet50 मॉडल है. इसे Imagenet डेटासेट पर पहले से ही ट्रेन किया गया है.
डेटा को अलग-अलग डिवाइसों पर ट्रेनिंग देने की सुविधा क्यों इस्तेमाल करें?
अगर आपके पास एक GPU है, तो TensorFlow इस एक्सेलेरेटर का इस्तेमाल करके मॉडल की ट्रेनिंग को तेज़ कर देगा. इसके लिए, आपको कुछ भी करने की ज़रूरत नहीं होगी. हालांकि, अगर आपको एक ही मशीन या कई मशीनों पर एक से ज़्यादा जीपीयू का इस्तेमाल करके, परफ़ॉर्मेंस को बेहतर बनाना है, तो आपको tf.distribute का इस्तेमाल करना होगा. यह TensorFlow की एक लाइब्रेरी है, जो कई डिवाइसों पर कंप्यूटेशन को चलाने के लिए इस्तेमाल की जाती है. डिवाइस का मतलब किसी ऐसी मशीन पर मौजूद सीपीयू या ऐक्सलरेटर से है जिस पर TensorFlow ऑपरेशन चला सकता है. जैसे, जीपीयू या टीपीयू.
डेटा को अलग-अलग डिवाइसों पर बांटकर ट्रेनिंग शुरू करने का सबसे आसान तरीका यह है कि एक ही मशीन पर कई जीपीयू डिवाइसों का इस्तेमाल किया जाए. tf.distribute मॉड्यूल से TensorFlow डिस्ट्रिब्यूशन रणनीति, सभी जीपीयू पर डेटा डिस्ट्रिब्यूशन और ग्रेडिएंट अपडेट के कोऑर्डिनेशन को मैनेज करेगी. अगर आपने सिंगल होस्ट ट्रेनिंग में महारत हासिल कर ली है और आपको इसे और बेहतर बनाना है, तो अपने क्लस्टर में एक से ज़्यादा मशीनें जोड़ने से, आपको परफ़ॉर्मेंस को और बेहतर बनाने में मदद मिल सकती है. आपके पास सिर्फ़ सीपीयू वाले मशीनों के क्लस्टर का इस्तेमाल करने का विकल्प होता है. इसके अलावा, आपके पास ऐसी मशीनों के क्लस्टर का इस्तेमाल करने का विकल्प भी होता है जिनमें एक या उससे ज़्यादा जीपीयू होते हैं. इस लैब में, दूसरे मामले के बारे में बताया गया है. साथ ही, यह दिखाया गया है कि Vertex AI पर कई मशीनों में TensorFlow मॉडल की ट्रेनिंग को डिस्ट्रिब्यूट करने के लिए, MultiWorkerMirroredStrategy का इस्तेमाल कैसे किया जाता है.
MultiWorkerMirroredStrategy एक सिंक्रोनस डेटा पैरललिज़्म रणनीति है. इसका इस्तेमाल, कोड में कुछ बदलाव करके किया जा सकता है. आपके क्लस्टर में मौजूद हर डिवाइस पर मॉडल की एक कॉपी बनाई जाती है. इसके बाद, ग्रेडिएंट अपडेट एक साथ होंगे. इसका मतलब है कि हर वर्कर डिवाइस, इनपुट डेटा के अलग-अलग स्लाइस पर मॉडल के ज़रिए फ़ॉरवर्ड और बैकवर्ड पास की गिनती करता है. इसके बाद, इन स्लाइस से कैलकुलेट किए गए ग्रेडिएंट को मशीन के सभी डिवाइसों और क्लस्टर की सभी मशीनों पर एग्रीगेट किया जाता है. साथ ही, इन्हें कम किया जाता है. इस प्रोसेस को ऑल-रिड्यूस कहा जाता है. आम तौर पर, यह औसत होता है. इसके बाद, ऑप्टिमाइज़र इन कम किए गए ग्रेडिएंट के साथ पैरामीटर अपडेट करता है. इससे डिवाइसों को सिंक रखा जाता है. TensorFlow की मदद से डिस्ट्रिब्यूटेड ट्रेनिंग के बारे में ज़्यादा जानने के लिए, यहां दिया गया वीडियो देखें:
4. अपना एनवायरमेंट सेट अप करने का तरीका
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको नोटबुक इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: Container Registry API चालू करना
Container Registry पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. इसका इस्तेमाल, कस्टम ट्रेनिंग जॉब के लिए कंटेनर बनाने के लिए किया जाएगा.
तीसरा चरण: Vertex AI API चालू करना
Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.
चालू होने के बाद, मैनेज की गई नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, बेहतर सेटिंग पर क्लिक करें.
ऐडवांस सेटिंग में जाकर, निष्क्रिय होने पर बंद होने की सुविधा चालू करें. इसके बाद, मिनट की संख्या को 60 पर सेट करें. इसका मतलब है कि इस्तेमाल न किए जाने पर, आपकी नोटबुक अपने-आप बंद हो जाएगी, ताकि आपको बिना वजह शुल्क न देना पड़े.
अगर सुरक्षा में जाकर "टर्मिनल चालू करें" विकल्प पहले से चालू नहीं है, तो इसे चालू करें.
अन्य सभी ऐडवांस सेटिंग को डिफ़ॉल्ट रूप से सेट रहने दें.
इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस को चालू होने में कुछ मिनट लगेंगे.
इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें.
पहली बार किसी नए इंस्टेंस का इस्तेमाल करते समय, आपसे पुष्टि करने के लिए कहा जाएगा. इसके लिए, यूज़र इंटरफ़ेस (यूआई) में दिया गया तरीका अपनाएं.
5. ट्रेनिंग ऐप्लिकेशन कोड को कंटेनर में रखना
आपको इस ट्रेनिंग जॉब को Vertex पर सबमिट करना होगा. इसके लिए, आपको अपने ट्रेनिंग ऐप्लिकेशन कोड को Docker कंटेनर में डालना होगा. इसके बाद, इस कंटेनर को Google Container Registry पर पुश करना होगा. इस तरीके का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.
शुरू करने के लिए, लॉन्चर मेन्यू से अपने नोटबुक इंस्टेंस में टर्मिनल विंडो खोलें:
cassava नाम की नई डायरेक्ट्री बनाएं और उसमें cd करें:
mkdir cassava
cd cassava
पहला चरण: Dockerfile बनाना
अपने कोड को कंटेनर में रखने के लिए, सबसे पहले Dockerfile बनाएं. Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी कमांड शामिल करें. इससे सभी ज़रूरी लाइब्रेरी इंस्टॉल हो जाएंगी और ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप हो जाएगा.
अपने टर्मिनल में, एक खाली 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, Deep Learning Container TensorFlow Enterprise 2.7 GPU 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पर सेट करता है. ऐसा इसलिए, क्योंकि कसावा डेटासेट को एक से ज़्यादा फ़ाइलों के तौर पर डाउनलोड नहीं किया जाता. हालांकि, अगर आपने नीति कोDATAपर सेट नहीं किया है, तो डिफ़ॉल्टAUTOनीति लागू हो जाएगी और नतीजा वही होगा.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 को आपके लिए अपने-आप सेट करता है. इसलिए, आपको अपने क्लस्टर में मौजूद हर मशीन पर इस वैरिएबल को तय करने की ज़रूरत नहीं है.
चौथा चरण: कंटेनर बनाना
अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, अपने टर्मिनल से यह कमांड चलाएं. साथ ही, यह पक्का करें कि आपने 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 Container Registry पर पुश करें:
docker push $IMAGE_URI
कंटेनर को Container Registry में पुश करने के बाद, अब ट्रेनिंग जॉब शुरू की जा सकती है.
6. Vertex AI पर, एक से ज़्यादा वर्कर का इस्तेमाल करके ट्रेनिंग वाला जॉब चलाना
इस लैब में, Google Container Registry पर मौजूद कस्टम कंटेनर के ज़रिए कस्टम ट्रेनिंग का इस्तेमाल किया जाता है. हालांकि, प्री-बिल्ट कंटेनर की मदद से भी ट्रेनिंग जॉब को चलाया जा सकता है.
शुरू करने के लिए, Cloud Console के Vertex सेक्शन में मौजूद ट्रेनिंग सेक्शन पर जाएं:
पहला चरण: ट्रेनिंग जॉब कॉन्फ़िगर करना
ट्रेनिंग जॉब के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें.
- डेटासेट में जाकर, कोई मैनेज किया गया डेटासेट नहीं चुनें
- इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (ऐडवांस) चुनें और जारी रखें पर क्लिक करें.
- मॉडल का नाम के लिए,
multiworker-cassavaडालें. इसके अलावा, अपने मॉडल के लिए कोई भी नाम डाला जा सकता है - जारी रखें पर क्लिक करें
कंटेनर की सेटिंग वाले चरण में, कस्टम कंटेनर चुनें:
पहले बॉक्स (कंटेनर इमेज) में, पिछले सेक्शन से अपने IMAGE_URI वैरिएबल की वैल्यू डालें. यह gcr.io/your-cloud-project/multiworker:cassava होना चाहिए. इसमें आपका प्रोजेक्ट आईडी शामिल होना चाहिए. बाकी फ़ील्ड को खाली छोड़ दें और जारी रखें पर क्लिक करें.
जारी रखें पर फिर से क्लिक करके, हाइपरपैरामीटर वाले चरण को छोड़ें.
दूसरा चरण: कंप्यूट क्लस्टर कॉन्फ़िगर करना
Vertex AI, अलग-अलग तरह के मशीन टास्क पूरे करने के लिए, चार वर्कर पूल उपलब्ध कराता है.
वर्कर पूल 0, प्राइमरी, चीफ़, शेड्यूलर या "मास्टर" को कॉन्फ़िगर करता है. MultiWorkerMirroredStrategy में, सभी मशीनों को वर्कर के तौर पर डेज़िग्नेट किया जाता है. ये वे फ़िज़िकल मशीनें होती हैं जिन पर रेप्लिका कंप्यूटेशन को एक्ज़ीक्यूट किया जाता है. हर मशीन को वर्कर के तौर पर इस्तेमाल किया जाता है. हालांकि, एक वर्कर को कुछ अतिरिक्त काम करने होते हैं. जैसे, चेकपॉइंट सेव करना और TensorBoard में खास जानकारी वाली फ़ाइलें लिखना. इस मशीन को मुख्य मशीन कहा जाता है. एक ही मुख्य वर्कर होता है. इसलिए, वर्कर पूल 0 के लिए वर्कर की संख्या हमेशा 1 होगी.
कंप्यूट और कीमत में, चुने गए क्षेत्र को वैसे ही रहने दें और वर्कर पूल 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()
आपको अपनी कंसोल के ट्रेनिंग सेक्शन में, CUSTOM JOBS टैब में अपनी ट्रेनिंग जॉब दिखेगी:
8. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक इस्तेमाल न किए जाने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने के बारे में चिंता करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, Stop बटन पर क्लिक करें. अगर आपको नोटबुक पूरी तरह से मिटानी है, तो 'मिटाएं' बटन पर क्लिक करें.
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
