TensorFlow Cloud

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें कागल लोगो Kaggle . में भागो

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

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

इसका मतलब है कि आप अपने Google क्लाउड कंप्यूट संसाधनों का उपयोग सीधे एक पायथन नोटबुक के अंदर से कर सकते हैं: इस तरह की एक नोटबुक! आप सादे .py Python स्क्रिप्ट से 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 अवधियों को) और फिर सेव GCS बाल्टी में प्रशिक्षित मॉडल और निर्देशिका ऊपर परिभाषित चलाते हैं।

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

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

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

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

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

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

# 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 इंस्टेंस फिर से कनेक्ट करें

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

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

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

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

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

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

०१५१८०४बी७०

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

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

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