टेंसरफ़्लो क्लाउड

TensorFlow.org पर देखें GitHub पर देखें नोटबुक डाउनलोड करें कागल लोगो कागल में भागो

TensorFlow Cloud एक लाइब्रेरी है जो Google क्लाउड पर Keras मॉडल का प्रशिक्षण और हाइपरपैरामीटर ट्यूनिंग करना आसान बनाती है।

टेन्सरफ्लो क्लाउड के run एपीआई का उपयोग करके, आप अपना मॉडल कोड सीधे अपने Google क्लाउड खाते पर भेज सकते हैं, और क्लाउड यूआई के साथ लॉगिन और इंटरैक्ट करने की आवश्यकता के बिना Google क्लाउड कंप्यूटिंग संसाधनों का उपयोग कर सकते हैं (एक बार जब आप कंसोल में अपना प्रोजेक्ट सेट कर लेते हैं)।

इसका मतलब यह है कि आप अपने Google क्लाउड कंप्यूट संसाधनों का उपयोग सीधे एक पायथन नोटबुक के अंदर से कर सकते हैं: बिल्कुल इस तरह की एक नोटबुक! आप सादे .py पायथन स्क्रिप्ट से भी मॉडल को Google क्लाउड पर भेज सकते हैं।

सरल उदाहरण

यह प्रदर्शित करने के लिए एक सरल परिचयात्मक उदाहरण है कि TensorFlow Cloud और Google Cloud का उपयोग करके किसी मॉडल को दूरस्थ रूप से कैसे प्रशिक्षित किया जाए।

यह कैसे काम करता है इसका अंदाजा लगाने के लिए आप इसे पढ़ सकते हैं, या आप Google Colab में नोटबुक चला सकते हैं। नोटबुक चलाने के लिए Google क्लाउड खाते से कनेक्ट करना और अपनी साख और प्रोजेक्ट आईडी दर्ज करना आवश्यक है। यदि आपके पास अभी तक कोई खाता नहीं है या आप सुनिश्चित नहीं हैं कि कंसोल में प्रोजेक्ट कैसे सेट करें तो अपने Google क्लाउड खाते को सेट अप करना और उससे कनेक्ट करना देखें।

आवश्यक मॉड्यूल आयात करें 

import tensorflow as tf
tf.version.VERSION

'2.6.0'

! pip install -q tensorflow-cloud
import tensorflow_cloud as tfc
print(tfc.__version__)

import sys

प्रोजेक्ट कॉन्फ़िगरेशन

प्रोजेक्ट पैरामीटर सेट करें. यदि आप नहीं जानते कि आपका GCP_PROJECT_ID या GCS_BUCKET क्या होना चाहिए, तो अपने Google क्लाउड खाते को सेट करना और कनेक्ट करना देखें।

JOB_NAME वैकल्पिक है, और आप इसे किसी भी स्ट्रिंग पर सेट कर सकते हैं। यदि आप एक बड़े प्रोजेक्ट के हिस्से के रूप में कई प्रशिक्षण प्रयोग (उदाहरण के लिए) कर रहे हैं, तो आप उनमें से प्रत्येक को एक अद्वितीय JOB_NAME देना चाह सकते हैं।

# Set Google Cloud Specific parameters

# TODO: Please set GCP_PROJECT_ID to your own Google Cloud project ID.
GCP_PROJECT_ID = 'YOUR_PROJECT_ID'

# TODO: set GCS_BUCKET to your own Google Cloud Storage (GCS) bucket.
GCS_BUCKET = 'YOUR_GCS_BUCKET_NAME'

# DO NOT CHANGE: Currently only the 'us-central1' region is supported.
REGION = 'us-central1'

# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'mnist'

# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")
MODEL_CHECKPOINT_DIR = os.path.join(GCS_BASE_PATH,"checkpoints")
SAVED_MODEL_DIR = os.path.join(GCS_BASE_PATH,"saved_model")

आपके Google क्लाउड प्रोजेक्ट का उपयोग करने के लिए नोटबुक को प्रमाणित किया जा रहा है

यह कोड आपके वैध Google क्लाउड क्रेडेंशियल्स और पहचान की जांच करके नोटबुक को प्रमाणित करता है। यह if not tfc.remote() ब्लॉक के अंदर है ताकि यह सुनिश्चित किया जा सके कि यह केवल नोटबुक में चलता है, और जब नोटबुक कोड Google क्लाउड पर भेजा जाता है तो नहीं चलाया जाएगा।

# Using tfc.remote() to ensure this code only runs in notebook
if not tfc.remote():

    # Authentication for Kaggle Notebooks
    if "kaggle_secrets" in sys.modules:
        from kaggle_secrets import UserSecretsClient
        UserSecretsClient().set_gcloud_credentials(project=GCP_PROJECT_ID)

    # Authentication for Colab Notebooks
    if "google.colab" in sys.modules:
        from google.colab import auth
        auth.authenticate_user()
        os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID

मॉडल और डेटा सेटअप

यहां से हम एमएनआईएसटी डेटासेट पर वर्गीकरण चलाने के लिए एक सरल केरस मॉडल स्थापित करने की बुनियादी प्रक्रिया का पालन कर रहे हैं।

डेटा लोड करें और विभाजित करें

कच्चे डेटा को पढ़ें और डेटा सेट को प्रशिक्षित और परीक्षण करने के लिए विभाजित करें।

(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()

x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255

एक मॉडल बनाएं और प्रशिक्षण के लिए तैयारी करें

एक सरल मॉडल बनाएं और उसके लिए कुछ कॉलबैक सेट करें।

from tensorflow.keras import layers

model = tf.keras.Sequential([
  tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy',
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])

त्वरित सत्यापन प्रशिक्षण

हम मॉडल को एक (1) युग के लिए प्रशिक्षित करेंगे ताकि यह सुनिश्चित हो सके कि सब कुछ सही ढंग से सेट हो गया है, और हम उस प्रशिक्षण कमांड को if not tfc.remote में लपेट देंगे, ताकि यह केवल रनटाइम वातावरण में ही हो जिसमें आप हैं इसे पढ़ रहे हैं, न कि तब जब इसे Google क्लाउड पर भेजा गया हो।

if not tfc.remote():
    # Run the training for 1 epoch and a small subset of the data to validate setup
    model.fit(x=x_train[:100], y=y_train[:100], validation_split=0.2, epochs=1)

दूरस्थ प्रशिक्षण के लिए तैयारी करें

नीचे दिया गया कोड केवल तभी चलेगा जब नोटबुक कोड Google क्लाउड पर भेजा जाएगा, उस रनटाइम के अंदर नहीं जिसमें आप इसे पढ़ रहे हैं।

सबसे पहले, हम कॉलबैक सेट करते हैं जो:

  • TensorBoard के लिए लॉग बनाएं।
  • चेकपॉइंट बनाएं और उन्हें ऊपर निर्दिष्ट चेकपॉइंट निर्देशिका में सहेजें।
  • यदि हानि में पर्याप्त सुधार नहीं हो रहा है तो मॉडल प्रशिक्षण बंद कर दें।

फिर हम model.fit और model.save को कॉल करते हैं, जो (जब यह कोड Google क्लाउड पर चल रहा होता है) जो वास्तव में पूर्ण प्रशिक्षण (100 युग) चलाता है और फिर प्रशिक्षित मॉडल को ऊपर परिभाषित जीसीएस बकेट और निर्देशिका में सहेजता है। 

if tfc.remote():
    # Configure Tensorboard logs
    callbacks=[
        tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR),
        tf.keras.callbacks.ModelCheckpoint(
            MODEL_CHECKPOINT_DIR,
            save_best_only=True),
        tf.keras.callbacks.EarlyStopping(
            monitor='loss',
            min_delta =0.001,
            patience=3)]

    model.fit(x=x_train, y=y_train, epochs=100,
              validation_split=0.2, callbacks=callbacks)

    model.save(SAVED_MODEL_DIR)

दूरस्थ प्रशिक्षण प्रारंभ करें

TensorFlow Cloud अपने स्थानीय निष्पादन वातावरण (इस नोटबुक) से सभी कोड लेता है, इसे लपेटता है, और निष्पादन के लिए Google क्लाउड को भेजता है। (यही कारण है कि if और if not tfc.remote रैपर महत्वपूर्ण हैं।)

यह चरण दूरस्थ निष्पादन के लिए इस नोटबुक से आपका कोड तैयार करेगा और फिर मॉडल को प्रशिक्षित करने के लिए Google क्लाउड प्लेटफ़ॉर्म पर एक दूरस्थ प्रशिक्षण कार्य शुरू करेगा।

सबसे पहले हम tensorflow-cloud पायथन पैकेज को एक requirements.txt फ़ाइल में जोड़ते हैं, जिसे इस नोटबुक में कोड के साथ भेजा जाएगा। आप आवश्यकतानुसार यहां अन्य पैकेज भी जोड़ सकते हैं।

फिर एक GPU और एक CPU छवि निर्दिष्ट की जाती है। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; निम्नलिखित कोड में GPU का उपयोग किया जाता है।

अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की बाकी फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि पर पैरामीटर निर्दिष्ट करते हैं कि GPU CPU छवियों का विवरण निर्दिष्ट किया गया है। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; निम्नलिखित कोड में GPU का उपयोग किया जाता है।

अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की बाकी फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि के पैरामीटर GPU और CPU छवियों का विवरण निर्दिष्ट करते हैं। आपको केवल एक या दूसरे को निर्दिष्ट करने की आवश्यकता है; निम्नलिखित कोड में GPU का उपयोग किया जाता है।

अंत में, TensorFlow क्लाउड का दिल: tfc.run पर कॉल। जब इसे इस नोटबुक के अंदर निष्पादित किया जाता है, तो इस नोटबुक के सभी कोड और इस निर्देशिका की बाकी फ़ाइलों को पैक किया जाएगा और निष्पादन के लिए Google क्लाउड पर भेजा जाएगा। run विधि के पैरामीटर उपयोग किए जाने वाले निष्पादन वातावरण और वितरण रणनीति (यदि कोई हो) का विवरण निर्दिष्ट करते हैं।

एक बार नौकरी सबमिट हो जाने के बाद आप टेन्सरबोर्ड के माध्यम से नौकरी की प्रगति की निगरानी करने के लिए अगले चरण पर जा सकते हैं। 

# If you are using a custom image you can install modules via requirements
# txt file.
with open('requirements.txt','w') as f:
    f.write('tensorflow-cloud\n')

# Optional: Some recommended base images. If you provide none the system
# will choose one for you.
TF_GPU_IMAGE= "tensorflow/tensorflow:latest-gpu"
TF_CPU_IMAGE= "tensorflow/tensorflow:latest"

# Submit a single node training job using GPU.
tfc.run(
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    docker_config=tfc.DockerConfig(
        parent_image=TF_GPU_IMAGE,
        image_build_bucket=GCS_BUCKET
        ),
    chief_config=tfc.COMMON_MACHINE_CONFIGS['K80_1X'],
    job_labels={'job': JOB_NAME}
)

प्रशिक्षण परिणाम

अपने Colab इंस्टेंस को पुनः कनेक्ट करें

अधिकांश दूरस्थ प्रशिक्षण नौकरियाँ लंबे समय तक चलने वाली होती हैं। यदि आप कोलाब का उपयोग कर रहे हैं, तो प्रशिक्षण परिणाम उपलब्ध होने से पहले इसका समय समाप्त हो सकता है।

उस स्थिति में, प्रशिक्षण परिणामों तक पहुंचने के लिए अपने कोलाब इंस्टेंस को फिर से कनेक्ट और कॉन्फ़िगर करने के लिए निम्नलिखित अनुभागों को फिर से चलाएँ ।

  1. आवश्यक मॉड्यूल आयात करें
  2. प्रोजेक्ट कॉन्फ़िगरेशन
  3. आपके Google क्लाउड प्रोजेक्ट का उपयोग करने के लिए नोटबुक को प्रमाणित किया जा रहा है

शेष कोड को दोबारा न चलाएँ।

टेंसरबोर्ड लोड करें

जब प्रशिक्षण चल रहा हो तो आप परिणाम देखने के लिए टेन्सरबोर्ड का उपयोग कर सकते हैं। ध्यान दें कि परिणाम आपका प्रशिक्षण शुरू होने के बाद ही दिखाई देंगे। इसमें कुछ मिनट का समय लगेगा। 

%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR

अपना प्रशिक्षित मॉडल लोड करें

एक बार प्रशिक्षण पूरा हो जाने पर, आप ऊपर निर्दिष्ट जीसीएस बकेट से अपना मॉडल पुनः प्राप्त कर सकते हैं। 

trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()